private async void SetupIntellisence() { if (this.CheckConnection()) { DbInterpreterOption option = new DbInterpreterOption() { ObjectFetchMode = DatabaseObjectFetchMode.Simple }; DbInterpreter dbInterpreter = DbInterpreterHelper.GetDbInterpreter(this.displayInfo.DatabaseType, this.displayInfo.ConnectionInfo, option); this.queryEditor.DbInterpreter = dbInterpreter; SchemaInfoFilter filter = new SchemaInfoFilter() { DatabaseObjectType = DatabaseObjectType.Table | DatabaseObjectType.Function | DatabaseObjectType.View | DatabaseObjectType.TableColumn }; SchemaInfo schemaInfo = await dbInterpreter.GetSchemaInfoAsync(filter); DataStore.SetSchemaInfo(this.displayInfo.DatabaseType, schemaInfo); this.queryEditor.SetupIntellisence(); } }
private async Task AddDbObjectNodes(TreeNode parentNode, string database, DatabaseObjectType databaseObjectType = DatabaseObjectType.None, bool createFolderNode = true) { DbInterpreter dbInterpreter = this.GetDbInterpreter(database); SchemaInfo schemaInfo = databaseObjectType == DatabaseObjectType.None ? new SchemaInfo() : await dbInterpreter.GetSchemaInfoAsync(new SchemaInfoFilter() { DatabaseObjectType = databaseObjectType }); this.ClearNodes(parentNode); this.AddTreeNodes(parentNode, databaseObjectType, DatabaseObjectType.Table, schemaInfo.Tables, createFolderNode, true); this.AddTreeNodes(parentNode, databaseObjectType, DatabaseObjectType.View, schemaInfo.Views, createFolderNode); this.AddTreeNodes(parentNode, databaseObjectType, DatabaseObjectType.Function, schemaInfo.Functions, createFolderNode); this.AddTreeNodes(parentNode, databaseObjectType, DatabaseObjectType.Procedure, schemaInfo.Procedures, createFolderNode); foreach (UserDefinedType userDefinedType in schemaInfo.UserDefinedTypes) { string text = $"{userDefinedType.Name}({userDefinedType.Type})"; string imageKeyName = nameof(userDefinedType); TreeNode node = DbObjectsTreeHelper.CreateTreeNode(userDefinedType.Name, text, imageKeyName); node.Tag = userDefinedType; parentNode.Nodes.Add(node); } }
private async void InitControls() { if (this.displayInfo.DatabaseType == DatabaseType.MySql) { this.tabControl1.TabPages.Remove(this.tabConstraints); } DbInterpreter dbInterpreter = this.GetDbInterpreter(); List <UserDefinedType> userDefinedTypes = await dbInterpreter.GetUserDefinedTypesAsync(); this.ucColumns.UserDefinedTypes = userDefinedTypes; this.ucColumns.InitControls(); if (this.displayInfo.IsNew) { this.LoadDatabaseOwners(); } else { this.cboOwner.Enabled = false; SchemaInfoFilter filter = new SchemaInfoFilter() { Strict = true, TableNames = new string[] { this.displayInfo.Name } }; filter.DatabaseObjectType = DatabaseObjectType.Table | DatabaseObjectType.TableColumn | DatabaseObjectType.TablePrimaryKey; SchemaInfo schemaInfo = await dbInterpreter.GetSchemaInfoAsync(filter); Table table = schemaInfo.Tables.FirstOrDefault(); if (table != null) { this.txtTableName.Text = table.Name; this.cboOwner.Text = table.Owner; this.txtTableComment.Text = table.Comment; #region Load Columns List <TableColumnDesingerInfo> columnDesingerInfos = ColumnManager.GetTableColumnDesingerInfos(dbInterpreter, table, schemaInfo.TableColumns, schemaInfo.TablePrimaryKeys); this.ucColumns.LoadColumns(table, columnDesingerInfos); #endregion } else { MessageBox.Show("Table is not existed"); } } }
private async Task AddDbObjectNodes(TreeNode parentNode, string database, DatabaseObjectType databaseObjectType = DatabaseObjectType.None, bool createFolderNode = true) { DbInterpreter dbInterpreter = this.GetDbInterpreter(database); SchemaInfo schemaInfo = databaseObjectType == DatabaseObjectType.None ? new SchemaInfo() : await dbInterpreter.GetSchemaInfoAsync(new SchemaInfoFilter() { DatabaseObjectType = databaseObjectType }); this.ClearNodes(parentNode); this.AddTreeNodes(parentNode, databaseObjectType, DatabaseObjectType.Table, schemaInfo.Tables, createFolderNode, true); this.AddTreeNodes(parentNode, databaseObjectType, DatabaseObjectType.View, schemaInfo.Views, createFolderNode); this.AddTreeNodes(parentNode, databaseObjectType, DatabaseObjectType.Function, schemaInfo.Functions, createFolderNode); this.AddTreeNodes(parentNode, databaseObjectType, DatabaseObjectType.Procedure, schemaInfo.Procedures, createFolderNode); }
public async Task LoadTree(DatabaseType dbType, ConnectionInfo connectionInfo, DatabaseObjectType excludeObjType = DatabaseObjectType.None) { this.tvDbObjects.Nodes.Clear(); DbInterpreterOption option = new DbInterpreterOption() { ObjectFetchMode = DatabaseObjectFetchMode.Simple }; DatabaseObjectType databaseObjectType = DatabaseObjectType.None; databaseObjectType = DbObjectsTreeHelper.DefaultObjectType; if (excludeObjType != DatabaseObjectType.None) { databaseObjectType = databaseObjectType ^ DatabaseObjectType.UserDefinedType; } DbInterpreter dbInterpreter = DbInterpreterHelper.GetDbInterpreter(dbType, connectionInfo, option); SchemaInfoFilter filter = new SchemaInfoFilter() { DatabaseObjectType = databaseObjectType }; SchemaInfo schemaInfo = await dbInterpreter.GetSchemaInfoAsync(filter); this.tvDbObjects.Nodes.AddDbObjectFolderNode(nameof(UserDefinedType), "User Defined Types", schemaInfo.UserDefinedTypes); this.tvDbObjects.Nodes.AddDbObjectFolderNode(nameof(Table), "Tables", schemaInfo.Tables); this.tvDbObjects.Nodes.AddDbObjectFolderNode(nameof(DatabaseInterpreter.Model.View), "Views", schemaInfo.Views); this.tvDbObjects.Nodes.AddDbObjectFolderNode(nameof(Function), "Functions", schemaInfo.Functions); this.tvDbObjects.Nodes.AddDbObjectFolderNode(nameof(Procedure), "Procedures", schemaInfo.Procedures); this.tvDbObjects.Nodes.AddDbObjectFolderNode(nameof(TableTrigger), "Triggers", schemaInfo.TableTriggers); if (this.tvDbObjects.Nodes.Count == 1) { this.tvDbObjects.ExpandAll(); } }
private async void GenerateScourceDbScripts() { SchemaInfo schemaInfo = this.GetSourceTreeSchemaInfo(); if (!this.ValidateSource(schemaInfo)) { return; } this.btnGenerateSourceScripts.Enabled = false; DatabaseType sourceDbType = this.GetDatabaseType(this.cboSourceDB.Text); int dataBatchSize = SettingManager.Setting.DataBatchSize; DbInterpreterOption sourceScriptOption = new DbInterpreterOption() { ScriptOutputMode = GenerateScriptOutputMode.WriteToFile, DataBatchSize = dataBatchSize }; this.SetGenerateScriptOption(sourceScriptOption); GenerateScriptMode scriptMode = this.GetGenerateScriptMode(); if (scriptMode == GenerateScriptMode.None) { MessageBox.Show("Please specify the script mode."); return; } DbInterpreter dbInterpreter = DbInterpreterHelper.GetDbInterpreter(sourceDbType, this.sourceDbConnectionInfo, sourceScriptOption); SelectionInfo selectionInfo = new SelectionInfo() { UserDefinedTypeNames = schemaInfo.UserDefinedTypes.Select(item => item.Name).ToArray(), TableNames = schemaInfo.Tables.Select(item => item.Name).ToArray(), ViewNames = schemaInfo.Views.Select(item => item.Name).ToArray() }; try { schemaInfo = await dbInterpreter.GetSchemaInfoAsync(selectionInfo); dbInterpreter.Subscribe(this); GenerateScriptMode mode = GenerateScriptMode.None; if (scriptMode.HasFlag(GenerateScriptMode.Schema)) { mode = GenerateScriptMode.Schema; dbInterpreter.GenerateSchemaScripts(schemaInfo); } if (scriptMode.HasFlag(GenerateScriptMode.Data)) { mode = GenerateScriptMode.Data; await dbInterpreter.GenerateDataScriptsAsync(schemaInfo); } this.OpenInExplorer(dbInterpreter.GetScriptOutputFilePath(mode)); MessageBox.Show(DONE); } catch (Exception ex) { this.HandleException(ex); } this.btnGenerateSourceScripts.Enabled = true; }
private async Task AddTableObjectNodes(TreeNode treeNode, Table table, DatabaseObjectType databaseObjectType) { string nodeName = treeNode.Name; string database = this.GetDatabaseNode(treeNode).Name; DbInterpreter dbInterpreter = this.GetDbInterpreter(database, false); dbInterpreter.Subscribe(this); SchemaInfo schemaInfo = await dbInterpreter.GetSchemaInfoAsync(new SchemaInfoFilter() { Strict = true, DatabaseObjectType = databaseObjectType, TableNames = new string[] { table.Name } }); this.ClearNodes(treeNode); #region Columns if (nodeName == nameof(DbObjectTreeFolderType.Columns)) { foreach (TableColumn column in schemaInfo.TableColumns) { string text = this.GetColumnText(dbInterpreter, table, column); bool isPrimaryKey = schemaInfo.TablePrimaryKeys.Any(item => item.Columns.Any(t => t.ColumnName == column.Name)); bool isForeignKey = schemaInfo.TableForeignKeys.Any(item => item.Columns.Any(t => t.ColumnName == column.Name)); string imageKeyName = isPrimaryKey ? nameof(TablePrimaryKey) : (isForeignKey ? nameof(TableForeignKey) : nameof(TableColumn)); TreeNode node = DbObjectsTreeHelper.CreateTreeNode(column.Name, text, imageKeyName); node.Tag = column; treeNode.Nodes.Add(node); } } #endregion if (nodeName == nameof(DbObjectTreeFolderType.Triggers)) { treeNode.AddDbObjectNodes(schemaInfo.TableTriggers); } #region Indexes if (nodeName == nameof(DbObjectTreeFolderType.Indexes) && schemaInfo.TableIndexes.Any()) { foreach (TableIndex index in schemaInfo.TableIndexes) { bool isUnique = index.IsUnique; string strColumns = string.Join(",", index.Columns.OrderBy(item => item.Order).Select(item => item.ColumnName)); string content = isUnique ? $"(Unique, {strColumns})" : $"({strColumns})"; string text = $"{index.Name}{content}"; string imageKeyName = nameof(TableIndex); TreeNode node = DbObjectsTreeHelper.CreateTreeNode(index.Name, text, imageKeyName); node.Tag = index; treeNode.Nodes.Add(node); } } #endregion if (nodeName == nameof(DbObjectTreeFolderType.Keys)) { foreach (TablePrimaryKey key in schemaInfo.TablePrimaryKeys) { TreeNode node = DbObjectsTreeHelper.CreateTreeNode(key); treeNode.Nodes.Add(node); } foreach (TableForeignKey key in schemaInfo.TableForeignKeys) { TreeNode node = DbObjectsTreeHelper.CreateTreeNode(key); treeNode.Nodes.Add(node); } } #region Constraints if (nodeName == nameof(DbObjectTreeFolderType.Constraints) && schemaInfo.TableConstraints.Any()) { foreach (TableConstraint constraint in schemaInfo.TableConstraints) { TreeNode node = DbObjectsTreeHelper.CreateTreeNode(constraint); treeNode.Nodes.Add(node); } } #endregion this.Feedback(""); }
private async Task InternalConvert(SchemaInfo schemaInfo = null) { DbInterpreter sourceInterpreter = this.Source.DbInterpreter; sourceInterpreter.Option.BulkCopy = this.Option.BulkCopy; sourceInterpreter.Subscribe(this.observer); sourceInterpreter.Option.GetTableAllObjects = false; sourceInterpreter.Option.ThrowExceptionWhenErrorOccurs = false; this.Target.DbInterpreter.Option.ThrowExceptionWhenErrorOccurs = false; if (string.IsNullOrEmpty(this.Target.DbOwner)) { if (this.Target.DbInterpreter.DatabaseType == DatabaseType.Oracle) { this.Target.DbOwner = (this.Target.DbInterpreter as OracleInterpreter).GetDbOwner(); } } DatabaseObjectType databaseObjectType = (DatabaseObjectType)Enum.GetValues(typeof(DatabaseObjectType)).Cast <int>().Sum(); if (schemaInfo != null && !this.Source.DbInterpreter.Option.GetTableAllObjects && (schemaInfo.TableTriggers == null || schemaInfo.TableTriggers.Count == 0)) { databaseObjectType = databaseObjectType ^ DatabaseObjectType.TableTrigger; } SchemaInfoFilter filter = new SchemaInfoFilter() { Strict = true, DatabaseObjectType = databaseObjectType }; SchemaInfoHelper.SetSchemaInfoFilterValues(filter, schemaInfo); SchemaInfo sourceSchemaInfo = await sourceInterpreter.GetSchemaInfoAsync(filter); if (sourceInterpreter.HasError) { return; } sourceSchemaInfo.TableColumns = DbObjectHelper.ResortTableColumns(sourceSchemaInfo.Tables, sourceSchemaInfo.TableColumns); if (SettingManager.Setting.NotCreateIfExists) { this.Target.DbInterpreter.Option.GetTableAllObjects = false; SchemaInfo targetSchema = await this.Target.DbInterpreter.GetSchemaInfoAsync(filter); SchemaInfoHelper.ExcludeExistingObjects(sourceSchemaInfo, targetSchema); } #region Set data type by user define type List <UserDefinedType> utypes = new List <UserDefinedType>(); if (sourceInterpreter.DatabaseType != this.Target.DbInterpreter.DatabaseType) { utypes = await sourceInterpreter.GetUserDefinedTypesAsync(); if (utypes != null && utypes.Count > 0) { foreach (TableColumn column in sourceSchemaInfo.TableColumns) { UserDefinedType utype = utypes.FirstOrDefault(item => item.Name == column.DataType); if (utype != null) { column.DataType = utype.Type; column.MaxLength = utype.MaxLength; } } } } #endregion SchemaInfo targetSchemaInfo = SchemaInfoHelper.Clone(sourceSchemaInfo); if (this.Source.TableNameMappings != null && this.Source.TableNameMappings.Count > 0) { SchemaInfoHelper.MapTableNames(targetSchemaInfo, this.Source.TableNameMappings); } if (this.Option.RenameTableChildren) { SchemaInfoHelper.RenameTableChildren(targetSchemaInfo); } if (this.Option.IgnoreNotSelfForeignKey) { targetSchemaInfo.TableForeignKeys = targetSchemaInfo.TableForeignKeys.Where(item => item.TableName == item.ReferencedTableName).ToList(); } #region Translate TranslateEngine translateEngine = new TranslateEngine(sourceSchemaInfo, targetSchemaInfo, sourceInterpreter, this.Target.DbInterpreter, this.Option, this.Target.DbOwner); translateEngine.SkipError = this.Option.SkipScriptError || this.Option.OnlyForTranslate; DatabaseObjectType translateDbObjectType = TranslateEngine.SupportDatabaseObjectType; if (!this.Option.GenerateScriptMode.HasFlag(GenerateScriptMode.Schema) && this.Option.BulkCopy && this.Target.DbInterpreter.SupportBulkCopy) { translateDbObjectType = DatabaseObjectType.TableColumn; } translateEngine.UserDefinedTypes = utypes; translateEngine.OnTranslated += this.Translated; translateEngine.Subscribe(this.observer); translateEngine.Translate(translateDbObjectType); if (this.Option.OnlyForTranslate) { if (targetSchemaInfo.Tables.Count == 0 && targetSchemaInfo.UserDefinedTypes.Count == 0) { return; } } #endregion if (targetSchemaInfo.Tables.Any()) { if (this.Option.EnsurePrimaryKeyNameUnique) { SchemaInfoHelper.EnsurePrimaryKeyNameUnique(targetSchemaInfo); } if (this.Option.EnsureIndexNameUnique) { SchemaInfoHelper.EnsureIndexNameUnique(targetSchemaInfo); } } DbInterpreter targetInterpreter = this.Target.DbInterpreter; bool generateIdentity = targetInterpreter.Option.TableScriptsGenerateOption.GenerateIdentity; if (generateIdentity) { targetInterpreter.Option.InsertIdentityValue = true; } string script = ""; targetInterpreter.Subscribe(this.observer); ScriptBuilder scriptBuilder = null; DbScriptGenerator targetDbScriptGenerator = DbScriptGeneratorHelper.GetDbScriptGenerator(targetInterpreter); if (this.Option.GenerateScriptMode.HasFlag(GenerateScriptMode.Schema)) { scriptBuilder = targetDbScriptGenerator.GenerateSchemaScripts(targetSchemaInfo); if (targetSchemaInfo.Tables.Any()) { this.Translated(targetInterpreter.DatabaseType, targetSchemaInfo.Tables.First(), new TranslateResult() { Data = scriptBuilder.ToString() }); } } if (this.Option.OnlyForTranslate) { return; } DataTransferErrorProfile dataErrorProfile = null; using (DbConnection dbConnection = this.Option.ExecuteScriptOnTargetServer ? targetInterpreter.CreateConnection() : null) { this.isBusy = true; if (this.Option.ExecuteScriptOnTargetServer && this.Option.UseTransaction) { dbConnection.Open(); this.transaction = dbConnection.BeginTransaction(); } #region Schema sync if (scriptBuilder != null && this.Option.ExecuteScriptOnTargetServer) { List <Script> scripts = scriptBuilder.Scripts; if (scripts.Count == 0) { this.Feedback(targetInterpreter, $"The script to create schema is empty.", FeedbackInfoType.Info); this.isBusy = false; return; } targetInterpreter.Feedback(FeedbackInfoType.Info, "Begin to sync schema..."); try { if (!this.Option.SplitScriptsToExecute) { targetInterpreter.Feedback(FeedbackInfoType.Info, script); await targetInterpreter.ExecuteNonQueryAsync(dbConnection, this.GetCommandInfo(script, null, this.transaction)); } else { Func <Script, bool> isValidScript = (s) => { return(!(s is NewLineSript || s is SpliterScript || string.IsNullOrEmpty(s.Content) || s.Content == targetInterpreter.ScriptsDelimiter)); }; int count = scripts.Where(item => isValidScript(item)).Count(); int i = 0; foreach (Script s in scripts) { if (targetInterpreter.HasError) { break; } if (!isValidScript(s)) { continue; } bool isCreateScript = s.ObjectType == nameof(Function) || s.ObjectType == nameof(Procedure) || s.ObjectType == nameof(TableTrigger); bool skipError = this.Option.SkipScriptError && isCreateScript; string sql = s.Content?.Trim(); if (!string.IsNullOrEmpty(sql) && sql != targetInterpreter.ScriptsDelimiter) { i++; if (!isCreateScript && targetInterpreter.ScriptsDelimiter.Length == 1 && sql.EndsWith(targetInterpreter.ScriptsDelimiter)) { sql = sql.TrimEnd(targetInterpreter.ScriptsDelimiter.ToArray()); } if (!targetInterpreter.HasError) { targetInterpreter.Feedback(FeedbackInfoType.Info, $"({i}/{count}), executing:{Environment.NewLine} {sql}"); CommandInfo commandInfo = this.GetCommandInfo(sql, null, transaction); commandInfo.SkipError = skipError; await targetInterpreter.ExecuteNonQueryAsync(dbConnection, commandInfo); } } } } } catch (Exception ex) { targetInterpreter.CancelRequested = true; this.Rollback(); ConnectionInfo sourceConnectionInfo = sourceInterpreter.ConnectionInfo; ConnectionInfo targetConnectionInfo = targetInterpreter.ConnectionInfo; SchemaTransferException schemaTransferException = new SchemaTransferException(ex) { SourceServer = sourceConnectionInfo.Server, SourceDatabase = sourceConnectionInfo.Database, TargetServer = targetConnectionInfo.Server, TargetDatabase = targetConnectionInfo.Database }; this.HandleError(schemaTransferException); } targetInterpreter.Feedback(FeedbackInfoType.Info, "End sync schema."); } #endregion #region Data sync if (!targetInterpreter.HasError && this.Option.GenerateScriptMode.HasFlag(GenerateScriptMode.Data) && sourceSchemaInfo.Tables.Count > 0) { List <TableColumn> identityTableColumns = new List <TableColumn>(); if (generateIdentity) { identityTableColumns = targetSchemaInfo.TableColumns.Where(item => item.IsIdentity).ToList(); } if (this.Option.PickupTable) { dataErrorProfile = DataTransferErrorProfileManager.GetProfile(sourceInterpreter.ConnectionInfo, targetInterpreter.ConnectionInfo); if (dataErrorProfile != null) { sourceSchemaInfo.PickupTable = new Table() { Owner = schemaInfo.Tables.FirstOrDefault()?.Owner, Name = dataErrorProfile.SourceTableName }; } } await this.SetIdentityEnabled(identityTableColumns, targetInterpreter, targetDbScriptGenerator, dbConnection, transaction, false); if (this.Option.ExecuteScriptOnTargetServer || targetInterpreter.Option.ScriptOutputMode.HasFlag(GenerateScriptOutputMode.WriteToFile)) { Dictionary <Table, long> dictTableDataTransferredCount = new Dictionary <Table, long>(); sourceInterpreter.OnDataRead += async(TableDataReadInfo tableDataReadInfo) => { if (!this.hasError) { Table table = tableDataReadInfo.Table; List <TableColumn> columns = tableDataReadInfo.Columns; try { (Table Table, List <TableColumn> Columns)targetTableAndColumns = this.GetTargetTableColumns(targetSchemaInfo, this.Target.DbOwner, table, columns); if (targetTableAndColumns.Table == null || targetTableAndColumns.Columns == null) { return; } if (this.Option.ExecuteScriptOnTargetServer) { DataTable dataTable = tableDataReadInfo.DataTable; List <Dictionary <string, object> > data = tableDataReadInfo.Data; if (this.Option.BulkCopy && targetInterpreter.SupportBulkCopy) { BulkCopyInfo bulkCopyInfo = this.GetBulkCopyInfo(table, targetSchemaInfo, this.transaction); if (targetInterpreter.DatabaseType == DatabaseType.Oracle) { if (columns.Any(item => item.DataType.ToLower().Contains("datetime2") || item.DataType.ToLower().Contains("timestamp"))) { bulkCopyInfo.DetectDateTimeTypeByValues = true; } } if (this.Option.ConvertComputeColumnExpression) { IEnumerable <DataColumn> dataColumns = dataTable.Columns.OfType <DataColumn>(); foreach (TableColumn column in bulkCopyInfo.Columns) { if (column.IsComputed && dataColumns.Any(item => item.ColumnName == column.Name)) { dataTable.Columns.Remove(column.Name); } } } await targetInterpreter.BulkCopyAsync(dbConnection, dataTable, bulkCopyInfo); } else { StringBuilder sb = new StringBuilder(); Dictionary <string, object> paramters = targetDbScriptGenerator.AppendDataScripts(sb, targetTableAndColumns.Table, targetTableAndColumns.Columns, new Dictionary <long, List <Dictionary <string, object> > >() { { 1, data } }); script = sb.ToString().Trim().Trim(';'); await targetInterpreter.ExecuteNonQueryAsync(dbConnection, this.GetCommandInfo(script, paramters, this.transaction)); } if (!dictTableDataTransferredCount.ContainsKey(table)) { dictTableDataTransferredCount.Add(table, dataTable.Rows.Count); } else { dictTableDataTransferredCount[table] += dataTable.Rows.Count; } long transferredCount = dictTableDataTransferredCount[table]; double percent = (transferredCount * 1.0 / tableDataReadInfo.TotalCount) * 100; string strPercent = (percent == (int)percent) ? (percent + "%") : (percent / 100).ToString("P2"); targetInterpreter.FeedbackInfo($"Table \"{table.Name}\":{dataTable.Rows.Count} records transferred.({transferredCount}/{tableDataReadInfo.TotalCount},{strPercent})"); } } catch (Exception ex) { sourceInterpreter.CancelRequested = true; this.Rollback(); ConnectionInfo sourceConnectionInfo = sourceInterpreter.ConnectionInfo; ConnectionInfo targetConnectionInfo = targetInterpreter.ConnectionInfo; string mappedTableName = this.GetMappedTableName(table.Name); DataTransferException dataTransferException = new DataTransferException(ex) { SourceServer = sourceConnectionInfo.Server, SourceDatabase = sourceConnectionInfo.Database, SourceObject = table.Name, TargetServer = targetConnectionInfo.Server, TargetDatabase = targetConnectionInfo.Database, TargetObject = mappedTableName }; this.HandleError(dataTransferException); if (!this.Option.UseTransaction) { DataTransferErrorProfileManager.Save(new DataTransferErrorProfile { SourceServer = sourceConnectionInfo.Server, SourceDatabase = sourceConnectionInfo.Database, SourceTableName = table.Name, TargetServer = targetConnectionInfo.Server, TargetDatabase = targetConnectionInfo.Database, TargetTableName = mappedTableName }); } } } }; } DbScriptGenerator sourceDbScriptGenerator = DbScriptGeneratorHelper.GetDbScriptGenerator(sourceInterpreter); await sourceDbScriptGenerator.GenerateDataScriptsAsync(sourceSchemaInfo); await this.SetIdentityEnabled(identityTableColumns, targetInterpreter, targetDbScriptGenerator, dbConnection, transaction, true); } #endregion if (this.transaction != null && this.transaction.Connection != null && !this.cancelRequested) { this.transaction.Commit(); } this.isBusy = false; } if (dataErrorProfile != null && !this.hasError && !this.cancelRequested) { DataTransferErrorProfileManager.Remove(dataErrorProfile); } }
public async Task <string> Generate(DatabaseObject dbObject, ScriptAction scriptAction) { string typeName = dbObject.GetType().Name; if (dbObject is Table) { dbInterpreter.Option.GetTableAllObjects = true; } DatabaseObjectType databaseObjectType = (DatabaseObjectType)Enum.Parse(typeof(DatabaseObjectType), typeName); SchemaInfoFilter filter = new SchemaInfoFilter() { DatabaseObjectType = databaseObjectType }; filter.GetType().GetProperty($"{typeName}Names").SetValue(filter, new string[] { dbObject.Name }); SchemaInfo schemaInfo = await dbInterpreter.GetSchemaInfoAsync(filter); DbScriptGenerator dbScriptGenerator = DbScriptGeneratorHelper.GetDbScriptGenerator(dbInterpreter); List <Script> scripts = dbScriptGenerator.GenerateSchemaScripts(schemaInfo).Scripts; StringBuilder sbContent = new StringBuilder(); DatabaseType databaseType = this.dbInterpreter.DatabaseType; foreach (Script script in scripts) { if (databaseType == DatabaseType.SqlServer && script is SpliterScript) { continue; } string content = script.Content; if (scriptAction == ScriptAction.ALTER && typeName != nameof(Table)) { string objType = typeName; if (typeName == nameof(TableTrigger)) { objType = "TRIGGER"; } string createFlag = "CREATE "; int createFlagIndex = this.GetCreateIndex(content, createFlag); if (createFlagIndex >= 0) { switch (databaseType) { case DatabaseType.SqlServer: content = content.Substring(0, createFlagIndex) + "ALTER " + content.Substring(createFlagIndex + createFlag.Length); break; case DatabaseType.MySql: content = $"DROP {objType} IF EXISTS {this.dbInterpreter.GetQuotedString(dbObject.Name)};" + Environment.NewLine + content; break; case DatabaseType.Oracle: if (!Regex.IsMatch(content, @"^(CREATE[\s]+OR[\s]+REPLACE[\s]+)", RegexOptions.IgnoreCase)) { content = content.Substring(0, createFlagIndex) + "CREATE OR REPLACE " + content.Substring(createFlagIndex + createFlag.Length); } break; } } } sbContent.AppendLine(content); } return(sbContent.ToString()); }