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); }