private void tlvDifferences_MouseDown(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Right)
{
if (this.tlvDifferences.Items.Count == 0)
{
return;
}
DbDifference difference = this.tlvDifferences.SelectedObject as DbDifference;
if (difference != null)
{
this.tsmiCollapseAll.Visible = this.tsmiExpandAll.Visible = this.CanExpand(difference);
this.tsmiGenerateChangedScripts.Visible = (difference.DifferenceType != DbDifferenceType.None && difference.DatabaseObjectType != DatabaseObjectType.None);
}
else
{
this.tsmiCollapseAll.Visible = this.tsmiExpandAll.Visible = true;
}
this.contextMenuStrip1.Show(Cursor.Position);
}
}
public List <Script> GenereateScriptDbObjectChangedScripts(DbDifference difference, string targetDbOwner)
{
List <Script> scripts = new List <Script>();
DbDifferenceType diffType = difference.DifferenceType;
ScriptDbObject sourceScriptDbObject = difference.Source as ScriptDbObject;
ScriptDbObject targetScriptDbObject = difference.Target as ScriptDbObject;
if (diffType == DbDifferenceType.Added)
{
var cloneObj = this.CloneDbObject(sourceScriptDbObject, targetDbOwner);
scripts.Add(new CreateDbObjectScript <ScriptDbObject>(cloneObj.Definition));
}
else if (diffType == DbDifferenceType.Deleted)
{
scripts.Add(this.targetScriptGenerator.Drop(sourceScriptDbObject));
}
else if (diffType == DbDifferenceType.Modified)
{
var cloneObj = this.CloneDbObject(sourceScriptDbObject, targetScriptDbObject.Owner);
scripts.Add(this.targetScriptGenerator.Drop(targetScriptDbObject));
scripts.Add(this.targetScriptGenerator.Add(cloneObj));
}
return(scripts);
}
public List <Script> GenereateUserDefinedTypeChangedScripts(DbDifference difference, string targetDbOwner)
{
List <Script> scripts = new List <Script>();
DbDifferenceType diffType = difference.DifferenceType;
UserDefinedType source = difference.Source as UserDefinedType;
UserDefinedType target = difference.Target as UserDefinedType;
if (diffType == DbDifferenceType.Added)
{
var cloneObj = this.CloneDbObject(source, targetDbOwner);
scripts.Add(this.targetScriptGenerator.AddUserDefinedType(cloneObj));
}
else if (diffType == DbDifferenceType.Deleted)
{
scripts.Add(this.targetScriptGenerator.DropUserDefinedType(source));
}
else if (diffType == DbDifferenceType.Modified)
{
var cloneObj = this.CloneDbObject(source, target.Owner);
scripts.Add(this.targetScriptGenerator.DropUserDefinedType(target));
scripts.Add(this.targetScriptGenerator.AddUserDefinedType(cloneObj));
}
return(scripts);
}
private void ShowScripts(DbDifference difference)
{
DatabaseObject source = difference.Source;
DatabaseObject target = difference.Target;
this.ShowSourceScripts(this.GetDatabaseObjectScripts(source, true));
this.ShowTargetScripts(this.GetDatabaseObjectScripts(target, false));
}
private void tlvDifferences_SelectedIndexChanged(object sender, EventArgs e)
{
DbDifference difference = this.tlvDifferences.SelectedObject as DbDifference;
if (difference != null)
{
this.ShowScripts(difference);
this.HighlightingDifferences(this.txtSource, this.txtTarget);
}
}
private List <DbDifference> CompareDatabaseObjects <T>(string type, DatabaseObjectType databaseObjectType, IEnumerable <T> sourceObjects, IEnumerable <T> targetObjects)
where T : DatabaseObject
{
List <DbDifference> differences = new List <DbDifference>();
foreach (T target in targetObjects)
{
DbDifference difference = new DbDifference()
{
Type = type, DatabaseObjectType = databaseObjectType
};
T source = sourceObjects.FirstOrDefault(item => this.IsNameEquals(item.Name, target.Name));
if (source == null)
{
difference.DifferenceType = DbDifferenceType.Deleted;
difference.Target = target;
differences.Add(difference);
}
else
{
difference.Source = source;
difference.Target = target;
if (!this.IsDbObjectEquals(source, target))
{
difference.DifferenceType = DbDifferenceType.Modified;
}
differences.Add(difference);
}
}
foreach (T source in sourceObjects)
{
if (!targetObjects.Any(item => this.IsNameEquals(item.Name, source.Name)))
{
DbDifference difference = new DbDifference()
{
Type = type, DatabaseObjectType = databaseObjectType
};
difference.DifferenceType = DbDifferenceType.Added;
difference.Source = source;
differences.Add(difference);
}
}
return(differences);
}
private void tsmiCollapseAll_Click(object sender, EventArgs e)
{
DbDifference difference = this.tlvDifferences.SelectedObject as DbDifference;
if (difference != null)
{
this.ExpandCollapseAllChildren(difference, false);
}
else
{
this.tlvDifferences.CollapseAll();
}
}
private void InitControls()
{
if (!this.useSourceConnector)
{
int increaseHeight = this.sourceDbProfile.Height;
this.sourceDbProfile.Visible = false;
this.btnCompare.Height = this.targetDbProfile.ClientHeight;
this.targetDbProfile.Top -= increaseHeight;
this.splitContainer1.Top -= increaseHeight;
this.splitContainer1.Height += increaseHeight;
}
this.colType.ImageGetter = delegate(object x)
{
DbDifference difference = x as DbDifference;
if (difference.DatabaseObjectType == DatabaseObjectType.None)
{
return("tree_Folder.png");
}
else
{
return($"tree_{difference.DatabaseObjectType}.png");
}
};
TreeRenderer treeColumnRenderer = this.tlvDifferences.TreeColumnRenderer;
treeColumnRenderer.IsShowGlyphs = true;
treeColumnRenderer.UseTriangles = true;
TreeRenderer renderer = this.tlvDifferences.TreeColumnRenderer;
renderer.LinePen = new Pen(Color.LightGray, 0.5f);
renderer.LinePen.DashStyle = DashStyle.Dot;
FlagRenderer differenceTypeRenderer = new FlagRenderer();
differenceTypeRenderer.ImageList = this.imageList2;
differenceTypeRenderer.Add(DbDifferenceType.Added, "Add.png");
differenceTypeRenderer.Add(DbDifferenceType.Modified, "Edit.png");
differenceTypeRenderer.Add(DbDifferenceType.Deleted, "Remove.png");
this.colChangeType.Renderer = differenceTypeRenderer;
this.colChangeType.ClusteringStrategy = new FlagClusteringStrategy(typeof(DbDifferenceType));
this.tlvDifferences.Refresh();
}
private IEnumerable <DbDifference> GetChildren(DbDifference difference)
{
if (this.differences == null)
{
return(Enumerable.Empty <DbDifference>());
}
var children = this.differences.Where(item => item.ParentType == difference.Type &&
((item.ParentName == null || (item.ParentName == difference.Source?.Name || item.ParentName == difference.Target?.Name)) ||
(item.ParentName == null || (item.ParentName == difference.Parent?.Source?.Name || item.ParentName == difference?.Parent.Target?.Name))
));
if (difference.DatabaseObjectType == DatabaseObjectType.Table)
{
return(this.GetTableChildrenFolders(difference.Source as Table, difference.Target as Table, difference));
}
else if (difference.Type == DbObjectTreeFolderType.Columns.ToString())
{
return(difference.Parent.SubDifferences.Where(item => item.DatabaseObjectType == DatabaseObjectType.TableColumn));
}
else if (difference.Type == "Primary Keys")
{
return(difference.Parent.SubDifferences.Where(item => item.DatabaseObjectType == DatabaseObjectType.TablePrimaryKey));
}
else if (difference.Type == "Foreign Keys")
{
return(difference.Parent.SubDifferences.Where(item => item.DatabaseObjectType == DatabaseObjectType.TableForeignKey));
}
else if (difference.Type == DbObjectTreeFolderType.Indexes.ToString())
{
return(difference.Parent.SubDifferences.Where(item => item.DatabaseObjectType == DatabaseObjectType.TableIndex));
}
else if (difference.Type == DbObjectTreeFolderType.Constraints.ToString())
{
return(difference.Parent.SubDifferences.Where(item => item.DatabaseObjectType == DatabaseObjectType.TableConstraint));
}
else if (difference.Type == DbObjectTreeFolderType.Triggers.ToString())
{
return(difference.Parent.SubDifferences.Where(item => item.DatabaseObjectType == DatabaseObjectType.TableTrigger));
}
else
{
return(children);
}
}
private void LoadData()
{
this.DecorateData(this.differences);
this.tlvDifferences.CanExpandGetter = delegate(object obj)
{
DbDifference difference = obj as DbDifference;
return(this.CanExpand(difference));
};
this.tlvDifferences.ChildrenGetter = delegate(object obj)
{
DbDifference difference = obj as DbDifference;
return(this.GetChildren(difference));
};
var roots = this.differences.Where(item => item.DatabaseObjectType == DatabaseObjectType.None);
this.tlvDifferences.Roots = roots;
}
private void ExpandCollapseAllChildren(DbDifference difference, bool isExpand)
{
if (this.tlvDifferences.CanExpand(difference))
{
if (isExpand)
{
this.tlvDifferences.Expand(difference);
}
else
{
this.tlvDifferences.Collapse(difference);
}
}
IEnumerable <DbDifference> children = this.tlvDifferences.GetChildren(difference).OfType <DbDifference>();
foreach (DbDifference child in children)
{
this.ExpandCollapseAllChildren(child, isExpand);
}
}
public async Task <List <Script> > GenerateTableChildChangedScripts(DbDifference difference)
{
List <Script> scripts = new List <Script>();
Table targetTable = difference.Parent.Target as Table;
DbDifferenceType diffType = difference.DifferenceType;
TableChild source = difference.Source as TableChild;
TableChild target = difference.Target as TableChild;
if (diffType == DbDifferenceType.Added)
{
scripts.Add(this.targetScriptGenerator.Add(this.CloneTableChild(source, difference.DatabaseObjectType, targetTable.Owner)));
}
else if (diffType == DbDifferenceType.Deleted)
{
scripts.Add(this.targetScriptGenerator.Drop(target));
}
else if (diffType == DbDifferenceType.Modified)
{
if (difference.DatabaseObjectType == DatabaseObjectType.TableColumn)
{
SchemaInfoFilter filter = new SchemaInfoFilter()
{
TableNames = new string[] { source.TableName }
};
List <TableDefaultValueConstraint> defaultValueConstraints = await this.tableManager.GetTableDefaultConstraints(filter);
Table table = new Table()
{
Owner = targetTable.Owner, Name = target.TableName
};
scripts.AddRange(this.tableManager.GetColumnAlterScripts(table, table, target as TableColumn, source as TableColumn, defaultValueConstraints));
}
else
{
var clonedSource = this.CloneTableChild(difference.Source, difference.DatabaseObjectType, targetTable.Owner);
if (difference.DatabaseObjectType == DatabaseObjectType.TablePrimaryKey)
{
scripts.AddRange(this.tableManager.GetPrimaryKeyAlterScripts(target as TablePrimaryKey, clonedSource as TablePrimaryKey, false));
}
else if (difference.DatabaseObjectType == DatabaseObjectType.TableForeignKey)
{
scripts.AddRange(this.tableManager.GetForeignKeyAlterScripts(target as TableForeignKey, clonedSource as TableForeignKey));
}
else if (difference.DatabaseObjectType == DatabaseObjectType.TableIndex)
{
scripts.AddRange(this.tableManager.GetIndexAlterScripts(target as TableIndex, clonedSource as TableIndex));
}
else if (difference.DatabaseObjectType == DatabaseObjectType.TableConstraint)
{
scripts.AddRange(this.tableManager.GetConstraintAlterScripts(target as TableConstraint, clonedSource as TableConstraint));
}
}
}
return(scripts);
}
public async Task <List <Script> > GenerateTableChangedScripts(SchemaInfo schemaInfo, DbDifference difference, string targetDbOwner)
{
List <Script> scripts = new List <Script>();
DbDifferenceType diffType = difference.DifferenceType;
Table sourceTable = difference.Source as Table;
Table targetTable = difference.Target as Table;
if (diffType == DbDifferenceType.Added)
{
List <TableColumn> columns = schemaInfo.TableColumns.Where(item => item.Owner == sourceTable.Owner && item.TableName == sourceTable.Name).OrderBy(item => item.Order).ToList();
TablePrimaryKey primaryKey = schemaInfo.TablePrimaryKeys.FirstOrDefault(item => item.Owner == sourceTable.Owner && item.TableName == sourceTable.Name);
List <TableForeignKey> foreignKeys = schemaInfo.TableForeignKeys.Where(item => item.Owner == sourceTable.Owner && item.TableName == sourceTable.Name).ToList();
List <TableIndex> indexes = schemaInfo.TableIndexes.Where(item => item.Owner == sourceTable.Owner && item.TableName == sourceTable.Name).OrderBy(item => item.Order).ToList();
List <TableConstraint> constraints = schemaInfo.TableConstraints.Where(item => item.Owner == sourceTable.Owner && item.TableName == sourceTable.Name).ToList();
this.ChangeOwner(columns, targetDbOwner);
primaryKey = this.CloneDbObject(primaryKey, targetDbOwner);
this.ChangeOwner(foreignKeys, targetDbOwner);
this.ChangeOwner(indexes, targetDbOwner);
this.ChangeOwner(constraints, targetDbOwner);
scripts.AddRange(this.targetScriptGenerator.AddTable(sourceTable, columns, primaryKey, foreignKeys, indexes, constraints).Scripts);
}
else if (diffType == DbDifferenceType.Deleted)
{
scripts.Add(this.targetScriptGenerator.DropTable(targetTable));
}
else if (diffType == DbDifferenceType.Modified)
{
if (!ValueHelper.IsStringEquals(sourceTable.Comment, targetTable.Comment))
{
scripts.Add(targetScriptGenerator.SetTableComment(sourceTable, string.IsNullOrEmpty(targetTable.Comment)));
}
foreach (DbDifference subDiff in difference.SubDifferences)
{
DbDifferenceType subDiffType = subDiff.DifferenceType;
if (subDiffType == DbDifferenceType.None)
{
continue;
}
DatabaseObjectType subDbObjectType = subDiff.DatabaseObjectType;
switch (subDbObjectType)
{
case DatabaseObjectType.TableColumn:
case DatabaseObjectType.TablePrimaryKey:
case DatabaseObjectType.TableForeignKey:
case DatabaseObjectType.TableIndex:
case DatabaseObjectType.TableConstraint:
scripts.AddRange(await this.GenerateTableChildChangedScripts(subDiff));
break;
case DatabaseObjectType.TableTrigger:
scripts.AddRange(this.GenereateScriptDbObjectChangedScripts(subDiff, targetDbOwner));
break;
}
}
}
return(scripts);
}
private async void tsmiGenerateChangedScripts_Click(object sender, EventArgs e)
{
DbDifference difference = this.tlvDifferences.SelectedObject as DbDifference;
await this.GenerateOrSync(false, difference);
}
private bool CanExpand(DbDifference difference)
{
DatabaseObjectType databaseObjectType = difference.DatabaseObjectType;
return(databaseObjectType == DatabaseObjectType.None || difference.DatabaseObjectType == DatabaseObjectType.Table);
}
public List <DbDifference> Compare()
{
List <DbDifference> differences = new List <DbDifference>();
differences.AddRange(this.CompareDatabaseObjects <UserDefinedType>(nameof(UserDefinedType), DatabaseObjectType.UserDefinedType, this.sourceShemaInfo.UserDefinedTypes, targetSchemaInfo.UserDefinedTypes));
#region Table
foreach (Table target in targetSchemaInfo.Tables)
{
DbDifference difference = new DbDifference()
{
Type = nameof(Table), DatabaseObjectType = DatabaseObjectType.Table
};
Table source = this.sourceShemaInfo.Tables.FirstOrDefault(item => this.IsNameEquals(item.Name, target.Name));
if (source == null)
{
difference.DifferenceType = DbDifferenceType.Deleted;
difference.Target = target;
differences.Add(difference);
}
else
{
difference.DifferenceType = DbDifferenceType.None;
difference.Source = source;
difference.Target = target;
differences.Add(difference);
bool isTableEquals = this.IsDbObjectEquals(source, target);
if (isTableEquals)
{
#region Column
IEnumerable <TableColumn> sourceColumns = this.sourceShemaInfo.TableColumns.Where(item => item.Owner == source.Owner && item.TableName == source.Name);
IEnumerable <TableColumn> targetColumns = this.targetSchemaInfo.TableColumns.Where(item => item.Owner == target.Owner && item.TableName == source.Name);
var columnDifferences = this.CompareTableChildren <TableColumn>("Column", DatabaseObjectType.TableColumn, sourceColumns, targetColumns);
difference.SubDifferences.AddRange(columnDifferences);
#endregion
#region Trigger
IEnumerable <TableTrigger> sourceTriggers = this.sourceShemaInfo.TableTriggers.Where(item => item.Owner == source.Owner && item.TableName == source.Name);
IEnumerable <TableTrigger> targetTriggers = this.targetSchemaInfo.TableTriggers.Where(item => item.Owner == target.Owner && item.TableName == source.Name);
var triggerDifferences = this.CompareDatabaseObjects <TableTrigger>("Trigger", DatabaseObjectType.TableTrigger, sourceTriggers, targetTriggers);
foreach (var triggerDiff in triggerDifferences)
{
triggerDiff.ParentName = target.Name;
}
difference.SubDifferences.AddRange(triggerDifferences);
#endregion
#region Index
IEnumerable <TableIndex> sourceIndexes = this.sourceShemaInfo.TableIndexes.Where(item => item.Owner == source.Owner && item.TableName == source.Name);
IEnumerable <TableIndex> targetIndexes = this.targetSchemaInfo.TableIndexes.Where(item => item.Owner == target.Owner && item.TableName == source.Name);
var indexDifferences = this.CompareTableChildren <TableIndex>("Index", DatabaseObjectType.TableIndex, sourceIndexes, targetIndexes);
difference.SubDifferences.AddRange(indexDifferences);
#endregion
#region Primary Key
IEnumerable <TablePrimaryKey> sourcePrimaryKeys = this.sourceShemaInfo.TablePrimaryKeys.Where(item => item.Owner == source.Owner && item.TableName == source.Name);
IEnumerable <TablePrimaryKey> targetPrimaryKeys = this.targetSchemaInfo.TablePrimaryKeys.Where(item => item.Owner == target.Owner && item.TableName == source.Name);
var primaryKeyDifferences = this.CompareTableChildren <TablePrimaryKey>("Primary Key", DatabaseObjectType.TablePrimaryKey, sourcePrimaryKeys, targetPrimaryKeys);
difference.SubDifferences.AddRange(primaryKeyDifferences);
#endregion
#region Foreign Key
IEnumerable <TableForeignKey> sourceForeignKeys = this.sourceShemaInfo.TableForeignKeys.Where(item => item.Owner == source.Owner && item.TableName == source.Name);
IEnumerable <TableForeignKey> targetForeignKeys = this.targetSchemaInfo.TableForeignKeys.Where(item => item.Owner == target.Owner && item.TableName == source.Name);
var foreignKeyDifferences = this.CompareTableChildren <TableForeignKey>("Foreign Key", DatabaseObjectType.TableForeignKey, sourceForeignKeys, targetForeignKeys);
difference.SubDifferences.AddRange(indexDifferences);
#endregion
#region Constraint
IEnumerable <TableConstraint> sourceConstraints = this.sourceShemaInfo.TableConstraints.Where(item => item.Owner == source.Owner && item.TableName == source.Name);
IEnumerable <TableConstraint> targetConstraints = this.targetSchemaInfo.TableConstraints.Where(item => item.Owner == target.Owner && item.TableName == source.Name);
var constraintDifferences = this.CompareTableChildren <TableConstraint>("Constraint", DatabaseObjectType.TableConstraint, sourceConstraints, targetConstraints);
difference.SubDifferences.AddRange(indexDifferences);
#endregion
difference.SubDifferences.ForEach(item => item.Parent = difference);
if (difference.SubDifferences.Any(item => item.DifferenceType != DbDifferenceType.None))
{
difference.DifferenceType = DbDifferenceType.Modified;
}
}
}
}
foreach (Table source in this.sourceShemaInfo.Tables)
{
if (!targetSchemaInfo.Tables.Any(item => this.IsNameEquals(item.Name, source.Name)))
{
DbDifference difference = new DbDifference()
{
Type = nameof(Table), DatabaseObjectType = DatabaseObjectType.Table
};
difference.DifferenceType = DbDifferenceType.Added;
difference.Source = source;
differences.Add(difference);
}
}
#endregion
differences.AddRange(this.CompareDatabaseObjects <View>(nameof(View), DatabaseObjectType.View, this.sourceShemaInfo.Views, targetSchemaInfo.Views));
differences.AddRange(this.CompareDatabaseObjects <Function>(nameof(Function), DatabaseObjectType.Function, this.sourceShemaInfo.Functions, targetSchemaInfo.Functions));
differences.AddRange(this.CompareDatabaseObjects <Procedure>(nameof(Procedure), DatabaseObjectType.Procedure, this.sourceShemaInfo.Procedures, targetSchemaInfo.Procedures));
return(differences);
}
private IEnumerable <DbDifference> GetTableChildrenFolders(Table source, Table target, DbDifference difference)
{
string tableName = source == null ? target.Name : source.Name;
List <DbDifference> differences = new List <DbDifference>();
Action <DatabaseObjectType, string> addFolder = (databaseObjectType, folderName) =>
{
if (difference.SubDifferences.Any(item => item.DatabaseObjectType == databaseObjectType))
{
differences.Add(new DbDifference()
{
Type = folderName, ParentType = nameof(Table), ParentName = tableName, Parent = difference, DifferenceType = this.GetTableSubFolderDiffType(difference, databaseObjectType)
});
}
};
addFolder(DatabaseObjectType.TableColumn, DbObjectTreeFolderType.Columns.ToString());
addFolder(DatabaseObjectType.TablePrimaryKey, "Primary Keys");
addFolder(DatabaseObjectType.TableForeignKey, "Foreign Keys");
addFolder(DatabaseObjectType.TableIndex, DbObjectTreeFolderType.Indexes.ToString());
addFolder(DatabaseObjectType.TableConstraint, DbObjectTreeFolderType.Constraints.ToString());
addFolder(DatabaseObjectType.TableTrigger, DbObjectTreeFolderType.Triggers.ToString());
return(differences);
}
private async Task GenerateOrSync(bool isSync, DbDifference difference = null)
{
if (this.sourceInterpreter == null || this.targetInterpreter == null || this.differences == null)
{
MessageBox.Show("Please compare first.");
return;
}
try
{
DbSynchro dbSynchro = new DbSynchro(this.sourceInterpreter, this.targetInterpreter);
if (!isSync)
{
List <Script> scripts = null;
string targetDbOwner = this.GetTargetDbOwner();
if (difference == null)
{
scripts = await dbSynchro.GenerateChangedScripts(this.sourceSchemaInfo, targetDbOwner, this.differences);
}
else if (difference.Source is ScriptDbObject || difference.Target is ScriptDbObject)
{
scripts = dbSynchro.GenereateUserDefinedTypeChangedScripts(difference, targetDbOwner);
}
else if (difference.DatabaseObjectType == DatabaseObjectType.Table)
{
scripts = await dbSynchro.GenerateTableChangedScripts(this.sourceSchemaInfo, difference, targetDbOwner);
}
else if (difference.Source is TableChild || difference.Target is TableChild)
{
scripts = await dbSynchro.GenerateTableChildChangedScripts(difference);
}
else if (difference.Source is UserDefinedType || difference.Target is UserDefinedType)
{
scripts = dbSynchro.GenereateUserDefinedTypeChangedScripts(difference, targetDbOwner);
}
if (scripts != null)
{
string strScripts = string.Join(Environment.NewLine, scripts.Select(item => item.Content));
frmScriptsViewer scriptsViewer = new frmScriptsViewer()
{
DatabaseType = this.targetInterpreter.DatabaseType
};
scriptsViewer.LoadScripts(StringHelper.ToSingleEmptyLine(strScripts).Trim());
scriptsViewer.ShowDialog();
}
}
else
{
if (MessageBox.Show("Are you sure to sync changes to target database?", "Confirm", MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == DialogResult.OK)
{
ContentSaveResult result = await dbSynchro.Sync(this.sourceSchemaInfo, this.GetTargetDbOwner(), this.differences);
if (result.IsOK)
{
MessageBox.Show("sync successfully.");
}
else
{
MessageBox.Show(result.Message);
}
}
}
}
catch (Exception ex)
{
this.HandleException(ex);
}
}
private DbDifferenceType GetTableSubFolderDiffType(DbDifference difference, DatabaseObjectType databaseObjectType)
{
return(difference.SubDifferences.Any(item => item.DatabaseObjectType == databaseObjectType && item.DifferenceType != DbDifferenceType.None) ? DbDifferenceType.Modified : DbDifferenceType.None);
}
