public SchemaDiff(IDocumentSchema schema, SchemaObjects existing, DocumentMapping mapping)
{
if (existing.HasNone())
{
AllMissing = true;
}
else
{
var expectedTable = mapping.SchemaObjects.As <DocumentSchemaObjects>().StorageTable();
TableDiff = new TableDiff(expectedTable, existing.Table);
// TODO -- drop obsolete indices?
mapping.Indexes.Each(index =>
{
if (existing.ActualIndices.ContainsKey(index.IndexName))
{
var actualIndex = existing.ActualIndices[index.IndexName];
if (!index.Matches(actualIndex))
{
IndexChanges.Add($"drop index {expectedTable.Table.Schema}.{index.IndexName};{Environment.NewLine}{index.ToDDL()};");
}
}
else
{
IndexChanges.Add(index.ToDDL());
}
});
}
_existing = existing;
_mapping = mapping;
}
private void compareIndices(Table expected, Table actual)
{
// TODO -- drop obsolete indices?
var schemaName = expected.Identifier.Schema;
foreach (var index in expected.Indexes)
{
if (actual.ActualIndices.ContainsKey(index.IndexName))
{
var actualIndex = actual.ActualIndices[index.IndexName];
if (!index.Matches(actualIndex))
{
IndexChanges.Add($"drop index {schemaName}.{index.IndexName};{Environment.NewLine}{index.ToDDL()};");
IndexRollbacks.Add($"drop index {schemaName}.{index.IndexName};{Environment.NewLine}{actualIndex.DDL};");
}
}
else
{
IndexChanges.Add(index.ToDDL());
IndexRollbacks.Add($"drop index concurrently if exists {schemaName}.{index.IndexName};");
}
}
var obsoleteIndexes = actual.ActualIndices.Values.Where(x => expected.Indexes.All(_ => _.IndexName != x.Name));
foreach (var index in obsoleteIndexes)
{
IndexRollbacks.Add(index.DDL);
IndexChanges.Add($"drop index concurrently if exists {schemaName}.{index.Name};");
}
}
public DatabaseModel(string name, DocumentStore documentStore)
{
this.name = name;
this.documentStore = documentStore;
Statistics = new Observable <DatabaseStatistics>();
Status = new Observable <string>
{
Value = "Offline"
};
OnPropertyChanged(() => StatusImage);
asyncDatabaseCommands = name.Equals(Constants.SystemDatabase, StringComparison.OrdinalIgnoreCase)
? documentStore.AsyncDatabaseCommands.ForSystemDatabase()
: documentStore.AsyncDatabaseCommands.ForDatabase(name);
DocumentChanges.Select(c => Unit.Default).Merge(IndexChanges.Select(c => Unit.Default))
.SampleResponsive(TimeSpan.FromSeconds(2))
.Subscribe(_ => RefreshStatistics());
databaseChanges.ConnectionStatusChanged += (sender, args) =>
{
ApplicationModel.Current.Server.Value.SetConnected(((IDatabaseChanges)sender).Connected);
UpdateStatus();
};
RefreshStatistics();
}
public DatabaseModel(string name, DocumentStore documentStore)
{
this.name = name;
this.documentStore = documentStore;
Tasks = new BindableCollection <TaskModel>(x => x.Name)
{
new ImportTask(),
new ExportTask(),
new StartBackupTask(),
new IndexingTask(),
new SampleDataTask()
};
SelectedTask = new Observable <TaskModel> {
Value = Tasks.FirstOrDefault()
};
Statistics = new Observable <DatabaseStatistics>();
Status = new Observable <string>
{
Value = "Offline"
};
asyncDatabaseCommands = name.Equals(Constants.SystemDatabase, StringComparison.OrdinalIgnoreCase)
? documentStore.AsyncDatabaseCommands.ForDefaultDatabase()
: documentStore.AsyncDatabaseCommands.ForDatabase(name);
DocumentChanges.Select(c => Unit.Default).Merge(IndexChanges.Select(c => Unit.Default))
.SampleResponsive(TimeSpan.FromSeconds(2))
.Subscribe(_ => RefreshStatistics(), exception => ApplicationModel.Current.Server.Value.IsConnected.Value = false);
RefreshStatistics();
}
public SchemaDiff(SchemaObjects existing, DocumentMapping mapping, DdlRules rules)
{
if (existing.HasNone())
{
AllMissing = true;
}
else
{
var expectedTable = mapping.SchemaObjects.As <DocumentSchemaObjects>().StorageTable();
TableDiff = new TableDiff(expectedTable, existing.Table);
// TODO -- drop obsolete indices?
mapping.Indexes.Each(index =>
{
if (existing.ActualIndices.ContainsKey(index.IndexName))
{
var actualIndex = existing.ActualIndices[index.IndexName];
if (!index.Matches(actualIndex))
{
IndexChanges.Add($"drop index {expectedTable.Table.Schema}.{index.IndexName};{Environment.NewLine}{index.ToDDL()};");
IndexRollbacks.Add($"drop index {expectedTable.Table.Schema}.{index.IndexName};{Environment.NewLine}{actualIndex.DDL};");
}
}
else
{
IndexChanges.Add(index.ToDDL());
IndexRollbacks.Add($"drop index concurrently if exists {expectedTable.Table.Schema}.{index.IndexName};");
}
});
existing.ActualIndices.Values.Where(x => mapping.Indexes.All(_ => _.IndexName != x.Name)).Each(
index =>
{
IndexRollbacks.Add(index.DDL);
IndexChanges.Add($"drop index concurrently if exists {mapping.Table.Schema}.{index.Name};");
});
var expectedFunction = new UpsertFunction(mapping);
FunctionDiff = new FunctionDiff(expectedFunction.ToBody(rules), existing.Function);
var missingFKs = mapping.ForeignKeys.Where(x => !existing.ForeignKeys.Contains(x.KeyName));
MissingForeignKeys.AddRange(missingFKs);
}
_mapping = mapping;
}
public bool HasDifferences()
{
if (AllMissing)
{
return(true);
}
if (!TableDiff.Matches)
{
return(true);
}
if (FunctionDiff.HasChanged)
{
return(true);
}
return(IndexChanges.Any() || MissingForeignKeys.Any());
}
public bool HasDifferences()
{
if (AllMissing)
{
return(true);
}
if (!TableDiff.Matches)
{
return(true);
}
if (HasFunctionChanged())
{
return(true);
}
return(IndexChanges.Any());
}
public DatabaseModel(string name, DocumentStore documentStore)
{
this.name = name;
this.documentStore = documentStore;
Tasks = new BindableCollection <TaskModel>(x => x.Name)
{
new ImportTask(),
new ExportTask(),
new StartBackupTask(),
new IndexingTask(),
new SampleDataTask(),
new CsvImportTask()
};
if (name == null || name == Constants.SystemDatabase)
{
Tasks.Insert(3, new StartRestoreTask());
}
SelectedTask = new Observable <TaskModel> {
Value = Tasks.FirstOrDefault()
};
Statistics = new Observable <DatabaseStatistics>();
Status = new Observable <string>
{
Value = "Offline"
};
OnPropertyChanged(() => StatusImage);
asyncDatabaseCommands = name.Equals(Constants.SystemDatabase, StringComparison.OrdinalIgnoreCase)
? documentStore.AsyncDatabaseCommands.ForDefaultDatabase()
: documentStore.AsyncDatabaseCommands.ForDatabase(name);
DocumentChanges.Select(c => Unit.Default).Merge(IndexChanges.Select(c => Unit.Default))
.SampleResponsive(TimeSpan.FromSeconds(2))
.Subscribe(_ => RefreshStatistics());
databaseChanges.ConnectionStatusCahnged += (sender, args) =>
{
ApplicationModel.Current.Server.Value.SetConnected(((IDatabaseChanges)sender).Connected);
UpdateStatus();
};
RefreshStatistics();
}
private void compareIndices(Table expected, Table actual)
{
// TODO -- drop obsolete indices?
var schemaName = expected.Identifier.Schema;
var obsoleteIndexes = actual.ActualIndices.Values.Where(x => expected.Indexes.All(_ => _.IndexName != x.Name));
foreach (var index in obsoleteIndexes)
{
IndexRollbacks.Add(index.DDL);
if (!index.Name.EndsWith("pkey"))
{
IndexChanges.Add($"drop index concurrently if exists {schemaName}.{index.Name};");
}
/* else
* {
* IndexChanges.Add($"alter table {_tableName} drop constraint if exists {schemaName}.{index.Name};");
* }*/
}
foreach (var index in expected.Indexes)
{
if (actual.ActualIndices.TryGetValue(index.IndexName, out var actualIndex))
{
if (!index.Matches(actualIndex))
{
IndexChanges.Add($"drop index {schemaName}.{index.IndexName};{Environment.NewLine}{index.ToDDL()};");
IndexRollbacks.Add($"drop index {schemaName}.{index.IndexName};{Environment.NewLine}{actualIndex.DDL};");
}
}
else
{
IndexChanges.Add(index.ToDDL());
IndexRollbacks.Add($"drop index concurrently if exists {schemaName}.{index.IndexName};");
}
}
}
