public override bool IsEqual(MySmoObjectBase newValue) { if (!base.IsEqual(newValue)) { return(false); } var productionForeignKey = (ForeignKey)SourceSmoObject; var sourceForeignKey = (ForeignKey)newValue.SourceSmoObject; if (productionForeignKey.Columns.Count != sourceForeignKey.Columns.Count) { return(false); } for (int num = 0; num < productionForeignKey.Columns.Count; num++) { ForeignKeyColumn productionForeignKeyColumn = productionForeignKey.Columns[num]; ForeignKeyColumn sourceForeignKeyColumn = sourceForeignKey.Columns[num]; if (productionForeignKeyColumn.Name != sourceForeignKeyColumn.Name || productionForeignKeyColumn.ReferencedColumn != sourceForeignKeyColumn.ReferencedColumn) { return(false); } } return(productionForeignKey.IsEnabled == sourceForeignKey.IsEnabled && productionForeignKey.IsChecked == sourceForeignKey.IsChecked && productionForeignKey.DeleteAction == sourceForeignKey.DeleteAction && productionForeignKey.UpdateAction == sourceForeignKey.UpdateAction && productionForeignKey.ReferencedTable == sourceForeignKey.ReferencedTable && productionForeignKey.ReferencedTableSchema == sourceForeignKey.ReferencedTableSchema); }
/// <summary> /// Return all objects from current table /// </summary> /// <param name="myObjectType">Model object for detect its type</param> /// <returns></returns> public Dictionary <string, MySmoObjectBase> GetMyObjects(MySmoObjectBase myObjectType) { if (myObjectType.SourceSmoObject.GetType() == typeof(Trigger)) { return(MyTriggers); } if (myObjectType.SourceSmoObject.GetType() == typeof(Index)) { return(MyIndexes); } if (myObjectType.SourceSmoObject.GetType() == typeof(ForeignKey)) { return(MyForeignKeys); } if (myObjectType.SourceSmoObject.GetType() == typeof(Column)) { return(MyColumns); } throw new Exception(string.Format( "Unknown type {0} in function GetMyObjects", myObjectType.SourceSmoObject.GetType())); }
public MySmoObjectBase(MySmoObjectBase mySmoObject) { SourceSmoObject = mySmoObject.SourceSmoObject; Name = mySmoObject.Name; ParentName = mySmoObject.ParentName; this.mProductionSmoObject = mySmoObject.mProductionSmoObject; ExtraParams = new string[mySmoObject.ExtraParams.Length]; mySmoObject.ExtraParams.CopyTo(ExtraParams, 0); }
public virtual bool IsEqual(MySmoObjectBase newValue) { if (ExtraParams.Length != newValue.ExtraParams.Length) { return(false); } if (this.ExtraParams.Where((t, i) => t != newValue.ExtraParams[i]).Any()) { return(false); } return(SourceSmoObject.GetType() == newValue.SourceSmoObject.GetType() && Name == newValue.Name); }
public override bool IsEqual(MySmoObjectBase newValue) { if (!base.IsEqual(newValue)) { return(false); } var productionColumn = (Column)SourceSmoObject; var sourceColumn = (Column)newValue.SourceSmoObject; if (productionColumn.Name == sourceColumn.Name && productionColumn.DataType.SqlDataType != sourceColumn.DataType.SqlDataType) { throw new Exception(string.Format( "Column {0}.{1} has different types in source and production databases", ((Table)productionColumn.Parent).Name, productionColumn.Name)); } if (productionColumn.DefaultConstraint != null) { if (sourceColumn.DefaultConstraint == null) { return(false); } string prodColName = ChangeName(productionColumn.DefaultConstraint.Name); string sourColName = ChangeName(sourceColumn.DefaultConstraint.Name); if (prodColName != sourColName || productionColumn.DefaultConstraint.Text != sourceColumn.DefaultConstraint.Text) { return(false); } } else { if (sourceColumn.DefaultConstraint != null) { return(false); } } return(productionColumn.Nullable == sourceColumn.Nullable && productionColumn.Identity == sourceColumn.Identity && productionColumn.IdentitySeed == sourceColumn.IdentitySeed && productionColumn.IdentityIncrement == sourceColumn.IdentityIncrement); }
public virtual bool IsEqual(MySmoObjectBase newValue) { if (ExtraParams.Length != newValue.ExtraParams.Length) { return(false); } for (int i = 0; i < ExtraParams.Length; i++) { if (ExtraParams[i] != newValue.ExtraParams[i]) { return(false); } } return(SourceSmoObject.GetType() == newValue.SourceSmoObject.GetType() && Name == newValue.Name); }
/// <summary> /// Get update information from two lists of smo ojects with current types: /// Views, CLRAssemblies and UserDefinedFunction (and other databases components) /// </summary> /// <param name="productionItems">Objects from production database</param> /// <param name="sourceItems">Objects from source database</param> /// <param name="dropItems">Objects for drop from production database</param> /// <param name="createItems">Objects for create in production database</param> private static void DifferentItems( Dictionary <string, MySmoObjectBase> productionItems, Dictionary <string, MySmoObjectBase> sourceItems, ICollection <MySmoObjectBase> dropItems, ICollection <MySmoObjectBase> createItems) { // // Get dropped items from production database // foreach (string productionItemKey in productionItems.Keys) { MySmoObjectBase productionItem = productionItems[productionItemKey]; bool isContains = false; if (sourceItems.ContainsKey(productionItemKey)) { MySmoObjectBase sourceItem = sourceItems[productionItemKey]; isContains = true; if (!productionItem.IsEqual(sourceItem)) { createItems.Add(new MySmoObjectBase(sourceItem)); isContains = false; } } if (!isContains) { dropItems.Add(new MySmoObjectBase(productionItem)); } } // // Get created items from source database // foreach (string sourceItemKey in sourceItems.Keys) { MySmoObjectBase sourceItem = sourceItems[sourceItemKey]; if (!productionItems.ContainsKey(sourceItemKey)) { createItems.Add(new MySmoObjectBase(sourceItem)); } } }
public override bool IsEqual(MySmoObjectBase newValue) { if (!base.IsEqual(newValue)) { return(false); } var productionTrigger = (Trigger)SourceSmoObject; var sourceTrigger = (Trigger)newValue.SourceSmoObject; return(productionTrigger.Delete == sourceTrigger.Delete && productionTrigger.DeleteOrder == sourceTrigger.DeleteOrder && productionTrigger.Insert == sourceTrigger.Insert && productionTrigger.InsertOrder == sourceTrigger.InsertOrder && productionTrigger.Update == sourceTrigger.Update && productionTrigger.UpdateOrder == sourceTrigger.UpdateOrder && productionTrigger.QuotedIdentifierStatus == sourceTrigger.QuotedIdentifierStatus); }
/// <summary> /// Get UserDefinedFunctions from indicated database /// </summary> /// <param name="database">Database</param> /// <returns></returns> public static Dictionary <string, MySmoObjectBase> GetUserDefinedFunctionsInfo(Microsoft.SqlServer.Management.Smo.Database database) { var userDefinedFunctions = new Dictionary <string, MySmoObjectBase>(); foreach (UserDefinedFunction userDefinedFunction in database.UserDefinedFunctions) { if (userDefinedFunction.IsSystemObject == false) { var mySmoObjectBase = new MySmoObjectBase( userDefinedFunction, userDefinedFunction.Name, database.Name, userDefinedFunction.TextBody, userDefinedFunction.TextHeader); userDefinedFunctions.Add(userDefinedFunction.Name, mySmoObjectBase); } } return(userDefinedFunctions); }
public override bool IsEqual(MySmoObjectBase newValue) { Trace.TraceInformation("Compare {0} procedures from {1} and {2} databases...\r\n", Name, ParentName, newValue.ParentName); if (!base.IsEqual(newValue)) { return(false); } var productionStoredProcedure = (StoredProcedure)SourceSmoObject; var sourceStoredProcedure = (StoredProcedure)newValue.SourceSmoObject; if (productionStoredProcedure.Parameters.Count != sourceStoredProcedure.Parameters.Count) { return(false); } foreach (StoredProcedureParameter productionStoredProcedureParameter in productionStoredProcedure.Parameters) { if (!sourceStoredProcedure.Parameters.Contains(productionStoredProcedureParameter.Name)) { return(false); } StoredProcedureParameter sourceStoredProcedureParameter = sourceStoredProcedure.Parameters[productionStoredProcedureParameter.Name]; if (sourceStoredProcedureParameter.DataType.SqlDataType != productionStoredProcedureParameter.DataType.SqlDataType || sourceStoredProcedureParameter.DataType.MaximumLength != productionStoredProcedureParameter.DataType.MaximumLength || sourceStoredProcedureParameter.DataType.NumericPrecision != productionStoredProcedureParameter.DataType.NumericPrecision || sourceStoredProcedureParameter.DataType.NumericScale != productionStoredProcedureParameter.DataType.NumericScale || sourceStoredProcedureParameter.DefaultValue != productionStoredProcedureParameter.DefaultValue || sourceStoredProcedureParameter.IsOutputParameter != productionStoredProcedureParameter.IsOutputParameter) { return(false); } } return(productionStoredProcedure.QuotedIdentifierStatus == sourceStoredProcedure.QuotedIdentifierStatus && productionStoredProcedure.Startup == sourceStoredProcedure.Startup); }
public override bool IsEqual(MySmoObjectBase newValue) { if (!base.IsEqual(newValue)) { return(false); } var productionIndex = (Index)SourceSmoObject; var sourceIndex = (Index)newValue.SourceSmoObject; // // Check include column and non include column separate // var includedColumnsProduction = new List <IndexedColumn>(); var includedColumnsSource = new List <IndexedColumn>(); var indexedColumnsProduction = new List <IndexedColumn>(); var indexedColumnsSource = new List <IndexedColumn>(); // Get production DB's columns for (int i = 0; i < productionIndex.IndexedColumns.Count; i++) { if (productionIndex.IndexedColumns[i].IsIncluded) { includedColumnsProduction.Add(productionIndex.IndexedColumns[i]); } else { indexedColumnsProduction.Add(productionIndex.IndexedColumns[i]); } } // Get source DB's columns for (int i = 0; i < sourceIndex.IndexedColumns.Count; i++) { if (sourceIndex.IndexedColumns[i].IsIncluded) { includedColumnsSource.Add(sourceIndex.IndexedColumns[i]); } else { indexedColumnsSource.Add(sourceIndex.IndexedColumns[i]); } } if (includedColumnsProduction.Count != includedColumnsSource.Count || indexedColumnsProduction.Count != indexedColumnsSource.Count) { return(false); } // Check include column foreach (IndexedColumn includedColumnSource in includedColumnsSource) { bool isContains = false; foreach (IndexedColumn includedColumnProduction in includedColumnsProduction) { if (includedColumnSource.Name == includedColumnProduction.Name && includedColumnSource.Descending == includedColumnProduction.Descending) { isContains = true; break; } } if (!isContains) { return(false); } } // Check non include column for (int i = 0; i < indexedColumnsSource.Count; i++) { if (indexedColumnsSource[i].Name != indexedColumnsProduction[i].Name || indexedColumnsSource[i].Descending != indexedColumnsProduction[i].Descending) { return(false); } } return(productionIndex.PadIndex == sourceIndex.PadIndex && productionIndex.FillFactor == sourceIndex.FillFactor && productionIndex.MaximumDegreeOfParallelism == sourceIndex.MaximumDegreeOfParallelism && productionIndex.SortInTempdb == sourceIndex.SortInTempdb && productionIndex.IsFullTextKey == sourceIndex.IsFullTextKey && productionIndex.DisallowPageLocks == sourceIndex.DisallowPageLocks && productionIndex.DisallowRowLocks == sourceIndex.DisallowRowLocks && productionIndex.IgnoreDuplicateKeys == sourceIndex.IgnoreDuplicateKeys && productionIndex.IndexKeyType == sourceIndex.IndexKeyType && productionIndex.IsClustered == sourceIndex.IsClustered && productionIndex.IsUnique == sourceIndex.IsUnique && productionIndex.NoAutomaticRecomputation == sourceIndex.NoAutomaticRecomputation && productionIndex.OnlineIndexOperation == sourceIndex.OnlineIndexOperation); }
/// <summary> /// Collect items from table: drop tables, create/drop triggers, create/drop checks, /// create/drop foreignKeys, create/drop/alter indexes and create/drop/alter columns /// </summary> /// <param name="createItems">List of items for creating</param> /// <param name="dropItems">List of items for deleting</param> /// <param name="alterItems">List of items for altering (not null only for column)</param> /// <param name="productionCollection">Collection of objects from production database</param> /// <param name="sourceCollection">Collection of objects from sourse database</param> /// <param name="productionTable">Production database (null for stored procedure)</param> private void DifferentSplitItems( ICollection <MySmoObjectBase> createItems, ICollection <MySmoObjectBase> dropItems, ICollection <MySmoObjectBase> alterItems, Dictionary <string, MySmoObjectBase> productionCollection, Dictionary <string, MySmoObjectBase> sourceCollection, Table productionTable) { #region Find object from production collection in source collection foreach (string productionObjectName in productionCollection.Keys) { MySmoObjectBase productionObject = productionCollection[productionObjectName]; // // if productionObject is split stored procedure - move to next object // if (productionTable == null && !string.IsNullOrEmpty( mDatabaseEngine.GetOriginalProcedureNameByTemplateProcedureName(productionObject.Name))) { continue; } bool isNeedDrop = true; if (sourceCollection.ContainsKey(productionObjectName)) { MySmoObjectBase sourceObject = sourceCollection[productionObjectName]; // // Compare these objects (own compare for every object) // if (sourceObject.IsEqual(productionObject)) { continue; } // // if our object is column - add it into alter collection // otherwise - into create and drop collection // if (alterItems != null) { var newMySmoObject = new MySmoObjectBase(sourceObject.CreateSplitItem(productionTable, 0, null)) { MProductionSmoObject = productionObject.SourceSmoObject }; alterItems.Add(newMySmoObject); isNeedDrop = false; } else { createItems.Add( productionTable != null ? new MySmoObjectBase(sourceObject.CreateSplitItem(productionTable, 0, null)) : new MySmoObjectBase(sourceObject.CreateSplitItem(this.mProductionDatabase, 0, null))); } #region Cycle for all split objects. We will create new split versions of object, if it have split versions if ((productionTable != null && Database.IsSplitTable(productionTable.Name)) || Database.IsSplitProcedure(sourceObject.Name)) { foreach (int surveyId in mDatabaseEngine.SurveyIds) { MySmoObjectBase splitObject; var splitTable = new Table(); if (productionTable != null) { // // Get split table // string splitTableName = Database.GetTemplateTableNameByOriginalTableName( productionTable.Name, surveyId); splitTable = mProductionDatabase.Tables[splitTableName]; // // Create split object on this table // splitObject = sourceObject.CreateSplitItem( splitTable, surveyId, mDatabaseEngine); } else { // // Create split stored procedure // splitObject = sourceObject.CreateSplitItem(mProductionDatabase, surveyId, mDatabaseEngine); } // // if our object is column - add it into alter collection // otherwise - into create collection // if (alterItems != null) { // // Find old version of this object in production database // var myTable = new MyTable(splitTable); Dictionary <string, MySmoObjectBase> templateCollection = myTable.GetMyObjects(splitObject); splitObject.MProductionSmoObject = templateCollection[splitObject.Name].SourceSmoObject; alterItems.Add(new MySmoObjectBase(splitObject)); } else { createItems.Add(new MySmoObjectBase(splitObject)); } } } #endregion } #region Add object and its split versions to drop collection if (isNeedDrop) { dropItems.Add(new MySmoObjectBase(productionObject)); // Add split objects to drop collection, if this table (stored procedure) // have split versions if ((productionTable != null && Database.IsSplitTable(productionTable.Name)) || Database.IsSplitProcedure(productionObject.Name)) { foreach (int surveyId in mDatabaseEngine.SurveyIds) { if (productionTable != null) { // // Get object collection from each split table // string splitTableName = Database.GetTemplateTableNameByOriginalTableName( productionTable.Name, surveyId); var myTable = new MyTable(mProductionDatabase.Tables[splitTableName]); Dictionary <string, MySmoObjectBase> templateCollection = myTable.GetMyObjects(productionObject); string splitObjectName = productionObject.Name; if (productionObject.SourceSmoObject.GetType() != typeof(Column)) { splitObjectName = Database.GetTemplateNameByOriginalName(productionObject.Name, surveyId); } // // Find our object from this collection and add it into drop collection // MySmoObjectBase splitObject = templateCollection[splitObjectName]; dropItems.Add(new MySmoObjectBase(splitObject)); } else { StoredProcedure splitProcedure = mProductionDatabase.StoredProcedures[Database.GetTemplateNameByOriginalName(productionObject.Name, surveyId)]; // If splitProcedure is (added just now) new procedure - // getting IsSystemObject parameter will throw exception try { if (!splitProcedure.IsSystemObject) { dropItems.Add(new MySmoObjectBase( splitProcedure, splitProcedure.Name, mProductionDatabase.Name)); } } catch (Microsoft.SqlServer.Management.Smo.PropertyNotSetException) { break; } } } } } #endregion } #endregion #region Add new objects from source database foreach (string sourceObjectName in sourceCollection.Keys) { MySmoObjectBase sourceObject = sourceCollection[sourceObjectName]; // // If source database contains new object - add it into create collection // if (!productionCollection.ContainsKey(sourceObjectName)) { if (productionTable != null) { var newObject = new MySmoObjectBase(sourceObject.CreateSplitItem(productionTable, 0, null)); // If column added to new table, we wount create new column separate, // it will create with table creating if (newObject.SourceSmoObject != null) { createItems.Add(newObject); } } else { createItems.Add(new MySmoObjectBase(sourceObject.CreateSplitItem(mProductionDatabase, 0, null))); } // // Add split objects, if this table (stored procedure) have split version // if ((productionTable != null && Database.IsSplitTable(productionTable.Name)) || Database.IsSplitProcedure(sourceObject.Name)) { foreach (int surveyId in mDatabaseEngine.SurveyIds) { MySmoObjectBase splitObject; if (productionTable != null) { string splitTableName = Database.GetTemplateTableNameByOriginalTableName( productionTable.Name, surveyId); // Create split object for split table splitObject = sourceObject.CreateSplitItem( mProductionDatabase.Tables[splitTableName], surveyId, mDatabaseEngine); } else { // Create split stored procedure splitObject = sourceObject.CreateSplitItem(mProductionDatabase, surveyId, mDatabaseEngine); } createItems.Add(new MySmoObjectBase(splitObject)); } } } } #endregion }