示例#1
0
 public override void BuildColumnModifySql(DbObjectChange change, DbColumnInfo column, DbScriptOptions options = DbScriptOptions.None)
 {
     var colSpec = GetColumnSpec(column, options);
       var tbl = column.Table;
       var scriptType = options.IsSet(DbScriptOptions.CompleteColumnSetup) ? DbScriptType.ColumnSetupComplete : DbScriptType.ColumnModify;
       change.AddScript(scriptType, "ALTER TABLE {0} MODIFY COLUMN {1};", tbl.FullName, colSpec);
 }
示例#2
0
 public override void BuildTableAddSql(DbObjectChange change, DbTableInfo table)
 {
     const string SqlTemplate = @"CREATE TABLE {0} (" + "\r\n {1} \r\n); ";
       var specs = table.Columns.Select(c => GetColumnSpec(c)).ToList();
       //Until now it was the same as default impl method in base class. Now we need to add Primary key and Foreign key constraints
       //Primary Key
       var pk = table.PrimaryKey;
       var col0 = pk.KeyColumns[0].Column;
       //Identity Primary Key is taken care of in GetColumnSpec
       // Note: looks like we need to declare identity PK in GetColumnSpec - SQLite is quite tricky in this way
       if (!col0.Flags.IsSet(DbColumnFlags.Identity)) {
     var strKeyCols = pk.KeyColumns.GetSqlNameList();
     var pkSpec = string.Format("PRIMARY KEY({0})", strKeyCols);
     specs.Add(pkSpec);
       }
       //Foreign keys (ref constraints
       foreach(var refC in table.RefConstraints) {
     var strKeyCols = refC.FromKey.KeyColumns.GetSqlNameList();
     //find target table
     var strPkKeyCols = refC.ToKey.KeyColumns.GetSqlNameList();
     var fkSpec = string.Format("FOREIGN KEY({0}) REFERENCES {1}({2})", strKeyCols, refC.ToKey.Table.TableName, strPkKeyCols);
     if(refC.CascadeDelete)
       fkSpec += " ON DELETE CASCADE";
     specs.Add(fkSpec);
       }
       //Build final Table statement
       var columnSpecs = string.Join("," + Environment.NewLine, specs);
       change.AddScript(DbScriptType.TableAdd, SqlTemplate, table.FullName, columnSpecs);
 }
示例#3
0
        internal DbObjectChange AddChange(DbModelObjectBase oldObj, DbModelObjectBase newObj, DbObjectChangeType?changeType = null, string notes = null)
        {
            var change = new DbObjectChange(oldObj, newObj, changeType, notes);

            this.Changes.Add(change);
            return(change);
        }
示例#4
0
        public DbObjectChange AddChange(DbModelObjectBase oldObject, DbModelObjectBase newObject, string notes = null)
        {
            var change = new DbObjectChange(oldObject, newObject, null, notes);

            NonTableChanges.Add(change);
            return(change);
        }
示例#5
0
 public DbUpgradeScript(DbScriptType scriptType, string sql, DbObjectChange modelChange = null, ApplyPhase phase = ApplyPhase.Default)
 {
     ScriptType     = scriptType;
     Sql            = sql;
     ModelChange    = modelChange;
     Phase          = phase;
     _creationOrder = System.Threading.Interlocked.Increment(ref _creationCount);
 }
示例#6
0
        private int _creationOrder; //used for keeping 'natural' (creation order) to later use it when applying scripts

        #endregion Fields

        #region Constructors

        public DbUpgradeScript(DbScriptType scriptType, string sql, DbObjectChange modelChange = null, ApplyPhase phase = ApplyPhase.Default)
        {
            ScriptType = scriptType;
              Sql = sql;
              ModelChange = modelChange;
              Phase = phase;
              _creationOrder = System.Threading.Interlocked.Increment(ref _creationCount);
        }
示例#7
0
 //ALTER TABLE employees DROP COLUMN "employee_num";
 public override void BuildColumnDropSql(DbObjectChange change, DbColumnInfo column)
 {
     if(!string.IsNullOrEmpty(column.DefaultExpression))
     change.AddScript(DbScriptType.ColumnModify, "ALTER TABLE {0} DROP CONSTRAINT \"{1}\";", column.Table.FullName, column.DefaultConstraintName);
       //Note: the column drop comes after table-rename, so it might be table is already renamed, and we have to get its new name
       var tableName = column.Table.Peer.FullName; //new name if renamed
       change.AddScript(DbScriptType.ColumnDrop, "ALTER TABLE {0} DROP COLUMN \"{1}\";", tableName, column.ColumnName);
 }
示例#8
0
 //not supported; all we can do is nullify it; so if it is a FK it no longer holds target refs
 public override void BuildColumnDropSql(DbObjectChange change, DbColumnInfo column)
 {
     //Note: the column drop comes after table-rename, so it might be table is already renamed, and we have to get its new name
       var tableName = column.Table.Peer.FullName; //new name if renamed
       if (column.Flags.IsSet(DbColumnFlags.Nullable) && column.Flags.IsSet(DbColumnFlags.ForeignKey)) {
     change.AddScript(DbScriptType.ColumnInit, "UPDATE {0} SET \"{1}\" = NULL;", tableName, column.ColumnName);
       }
 }
示例#9
0
 public override void BuildStoredProcDropSql(DbObjectChange change, DbCommandInfo command)
 {
     if(command.CustomTag == null) { //try to recover it
     var inpParams = command.Parameters.Where(p => p.Direction != ParameterDirection.Output);
     command.CustomTag = string.Join(", ", inpParams.Select(p => p.TypeInfo.SqlTypeSpec));
       }
       var funcRef = string.Format(@"{0}.""{1}""({2})", command.Schema, command.CommandName, command.CustomTag);
       change.AddScript(DbScriptType.RoutineDrop, "DROP FUNCTION {0};", funcRef);
 }
示例#10
0
 public override void BuildCustomTypeAddSql(DbObjectChange change, DbCustomTypeInfo typeInfo)
 {
     var sqlCreateTemplate = "CREATE TYPE {0} AS TABLE ([Value] Sql_Variant);";
       var sqlGrantTemplate = "Grant EXECUTE on TYPE::{0} to {1};";
       change.AddScript(DbScriptType.CustomTypeAdd, sqlCreateTemplate, typeInfo.FullName);
       if (!string.IsNullOrWhiteSpace(Settings.GrantExecReadToRole))
     change.AddScript(DbScriptType.CustomTypeAdd, sqlGrantTemplate, typeInfo.FullName, Settings.GrantExecReadToRole);
       if (!string.IsNullOrWhiteSpace(Settings.GrantExecWriteToRole) && Settings.GrantExecWriteToRole != Settings.GrantExecReadToRole)
     change.AddScript(DbScriptType.CustomTypeAdd, sqlGrantTemplate, typeInfo.FullName, Settings.GrantExecWriteToRole);
 }
示例#11
0
 //ALTER TABLE employees ALTER COLUMN [employee_name] nvarchar(100) Null;
 public virtual void BuildColumnModifySql(DbObjectChange change, DbColumnInfo column, DbScriptOptions options = DbScriptOptions.None)
 {
     var scriptType = options.IsSet(DbScriptOptions.CompleteColumnSetup) ? DbScriptType.ColumnSetupComplete : DbScriptType.ColumnModify;
       if(ShouldResetNullsToDefault(column)) {
     BuildColumnSetDefaultValuesSql(change, column);
     scriptType = DbScriptType.ColumnSetupComplete;
       }
       var colSpec = GetColumnSpec(column);
       change.AddScript(scriptType,
     "ALTER TABLE {0} ALTER COLUMN {1};", column.Table.FullName, colSpec);
 }
示例#12
0
 public override void BuildColumnModifySql(DbObjectChange change, DbColumnInfo column, DbScriptOptions options = DbScriptOptions.None)
 {
     if(ShouldResetNullsToDefault(column))
     BuildColumnSetDefaultValuesSql(change, column);
       // In Pg you modify column one aspect at a time; setting TYPE and Nullable requires 2 calls
       change.AddScript(DbScriptType.ColumnModify, "ALTER TABLE {0} ALTER COLUMN \"{1}\" TYPE {2};",
     column.Table.FullName, column.ColumnName, column.TypeInfo.SqlTypeSpec);
       var nullStr = column.Flags.IsSet(DbColumnFlags.Nullable) ? "DROP NOT NULL" : "SET NOT NULL";
       change.AddScript(DbScriptType.ColumnSetupComplete, "ALTER TABLE {0} ALTER COLUMN \"{1}\" {2};",
     column.Table.FullName, column.ColumnName, nullStr);
 }
示例#13
0
 public override void BuildColumnModifySql(DbObjectChange change, DbColumnInfo column, DbScriptOptions options = DbScriptOptions.None)
 {
     //SqlCe does not allow any modification of 'ntext'/memo columns
       var dbType = column.TypeInfo.VendorDbType.DbType;
       bool isNText = column.TypeInfo.Size < 0 && (dbType == DbType.String || dbType == DbType.Binary);
       if(isNText) {
     change.NotSupported("Modifying ntext column not supported in SqlCE. Column: {0}.{1}", column.Table.TableName, column.ColumnName);
     return;
       }
       base.BuildColumnModifySql(change, column, options);
 }
示例#14
0
        public override void BuildPrimaryKeyAddSql(DbObjectChange change, DbKeyInfo key)
        {
            // PK for Identity (Auto-increment) columns is created when table/ID columns is created
              if(key.KeyColumns[0].Column.Flags.IsSet(DbColumnFlags.Identity)) {
            change.AddScript(DbScriptType.PrimaryKeyAdd, "-- PrimaryKeyAdd empty action");
            return;
              }

              var fullTableRef = key.Table.FullName;
              var pkFields = key.KeyColumns.GetSqlNameList();
              // PK name is always 'PRIMARY'
              change.AddScript(DbScriptType.PrimaryKeyAdd, "ALTER TABLE {0} ADD CONSTRAINT PRIMARY KEY ({1});", fullTableRef, pkFields);
        }
示例#15
0
        public override void BuildColumnAddSql(DbObjectChange change, DbColumnInfo column, DbScriptOptions options)
        {
            var colSpec = GetColumnSpec(column, options);
              if(!column.Flags.IsSet(DbColumnFlags.Nullable)) {
            var dft = column.TypeInfo.VendorDbType.DefaultColumnInit;
            if (string.IsNullOrWhiteSpace(dft))
              dft = column.TypeInfo.ToLiteral(new byte[] {0});
            colSpec += " DEFAULT " + dft;

              }
              //workaround for unit test with renaming table - ignore rename, use old table
              var tbl = column.Table;
              if (tbl.Peer != null)
            tbl = tbl.Peer; //use old table name
              change.AddScript(DbScriptType.ColumnAdd, "ALTER TABLE {0} ADD {1};", tbl.FullName, colSpec);
        }
示例#16
0
 public override void BuildIndexAddSql(DbObjectChange change, DbKeyInfo key)
 {
     const string CreateIndexTemplate = @"
     CREATE {0} {1} INDEX {2}
       ON {3} ( {4} )
       {5}
       {6}
     ";
       var unique = key.KeyType.IsSet(KeyType.Unique) ? "UNIQUE" : string.Empty;
       string clustered = GetClusteredExpression(key);
       var indexFields = key.KeyColumns.GetSqlNameListWithOrderSpec();
       var qKeyName = '"' + key.Name + '"';
       string includeList = string.Empty;
       if(key.IncludeColumns.Count > 0)
     includeList = "INCLUDE (" + key.IncludeColumns.GetSqlNameList() + ")";
       string wherePred = string.Empty;
       if(!string.IsNullOrWhiteSpace(key.Filter))
     wherePred = "WHERE " + key.Filter;
       var phase = key.KeyType.IsSet(KeyType.Clustered) ? ApplyPhase.Early : ApplyPhase.Default;
       change.AddScript(DbScriptType.IndexAdd, phase, CreateIndexTemplate,
     unique, clustered, qKeyName, key.Table.FullName, indexFields, includeList, wherePred);
 }
示例#17
0
 public override void BuildViewAddSql(DbObjectChange change, DbTableInfo view)
 {
     const string createViewTemplate =
     @"CREATE {0} VIEW {1}  AS
       {2};
       COMMENT ON {0} VIEW {1} IS '{3}';
     "; //notice - no ';' at the end, SQL must have it already
       // For indexed views add 'MATERIALIZED' attribute
       var matz = view.IsMaterializedView ? "MATERIALIZED" : string.Empty;
       //var escapedSql = view.ViewSql.Replace("'", "''");
       change.AddScript(DbScriptType.ViewAdd, createViewTemplate, matz, view.FullName, view.ViewSql, view.ViewHash);
 }
示例#18
0
 public override void BuildTableRenameSql(DbObjectChange change, DbTableInfo oldTable, DbTableInfo newTable)
 {
     change.AddScript(DbScriptType.TableRename, "ALTER TABLE {0} RENAME TO \"{1}\" ;", oldTable.FullName, newTable.TableName);
 }
示例#19
0
 //Helper methods
 protected virtual void BuildColumnRenameSqlWithAddDrop(DbObjectChange change, DbColumnInfo oldColumn, DbColumnInfo newColumn)
 {
     //Add new column
       BuildColumnAddSql(change, newColumn, DbScriptOptions.ForceNull);
       // copy data
       change.AddScript(DbScriptType.ColumnCopyValues,
     "UPDATE {0} SET \"{1}\" = \"{2}\";", oldColumn.Table.FullName, newColumn.ColumnName, oldColumn.ColumnName);
       // finalize added column
       BuildColumnModifySql(change, newColumn, DbScriptOptions.CompleteColumnSetup);
       //drop old column
       BuildColumnDropSql(change, oldColumn);
 }
示例#20
0
 public override void BuildSequenceDropSql(DbObjectChange change, DbSequenceInfo sequence)
 {
     // PG creates sequences for identity columns, these should not be dropped explicitly; we do sequence drop after table drop, so we add check for existense
       change.AddScript(DbScriptType.SequenceDrop, "DROP SEQUENCE IF EXISTS {0}", sequence.FullName);
 }
示例#21
0
 public override void BuildSequenceAddSql(DbObjectChange change, DbSequenceInfo sequence)
 {
     var start = (sequence.StartValue < 1) ? 1 : sequence.StartValue;
       const string sqlTemplate = "CREATE Sequence {0} START WITH {1} INCREMENT BY {2};";
       change.AddScript(DbScriptType.SequenceAdd, sqlTemplate, sequence.FullName,  start, sequence.Increment);
 }
示例#22
0
 public virtual void BuildCustomTypeDropSql(DbObjectChange change, DbCustomTypeInfo typeInfo)
 {
 }
示例#23
0
 //ALTER TABLE employees DROP COLUMN [employee_pwd];
 public virtual void BuildColumnDropSql(DbObjectChange change, DbColumnInfo column)
 {
     //Note: the column drop comes after table-rename, so it might be table is already renamed, and we have to get its new name
       var tableName = column.Table.Peer.FullName; //new name if renamed
       change.AddScript(DbScriptType.ColumnDrop, "ALTER TABLE {0} DROP COLUMN \"{1}\"", tableName, column.ColumnName);
 }
示例#24
0
 public override void BuildColumnRenameSql(DbObjectChange change, DbColumnInfo oldColumn, DbColumnInfo newColumn)
 {
     change.AddScript(DbScriptType.ColumnRename, "ALTER TABLE {0} RENAME COLUMN \"{1}\" TO \"{2}\";", newColumn.Table.FullName, oldColumn.ColumnName, newColumn.ColumnName);
 }
示例#25
0
 public virtual void BuildColumnRenameSql(DbObjectChange change, DbColumnInfo oldColumn, DbColumnInfo newColumn)
 {
     Util.Throw("Column renaming is not supported by DbDriver {0}.", this.GetType());
 }
示例#26
0
 public override void BuildViewDropSql(DbObjectChange change, DbTableInfo view)
 {
     var matzed = view.IsMaterializedView ? "MATERIALIZED" : string.Empty;
       change.AddScript(DbScriptType.ViewDrop, "DROP {0} VIEW {1};", matzed, view.FullName);
       //base.BuildViewDropSql(change, view);
 }
示例#27
0
 public virtual void BuildIndexAddSql(DbObjectChange change, DbKeyInfo key)
 {
     const string CreateIndexTemplate = @"
     CREATE {0} INDEX {1}
       ON {2} ( {3} )
       {4}
       {5}
     ";
       var driver = this.Settings.Driver;
       var unique = key.KeyType.IsSet(KeyType.Unique) ? "UNIQUE" : string.Empty;
       string indexFields;
       if(driver.Supports(DbFeatures.OrderedColumnsInIndexes))
     indexFields = key.KeyColumns.GetSqlNameListWithOrderSpec();
       else
     indexFields = key.KeyColumns.GetSqlNameList();
       var qKeyName = '"' + key.Name + '"';
       string includeList = string.Empty;
       if(key.IncludeColumns.Count > 0 && driver.Supports(DbFeatures.IncludeColumnsInIndexes))
     includeList = "INCLUDE (" + key.IncludeColumns.GetSqlNameList() + ")";
       string wherePred = string.Empty;
       if(!string.IsNullOrWhiteSpace(key.Filter) && driver.Supports(DbFeatures.FilterInIndexes))
     wherePred = "WHERE " + key.Filter;
       change.AddScript(DbScriptType.IndexAdd, CreateIndexTemplate, unique, qKeyName, key.Table.FullName, indexFields, includeList, wherePred);
 }
示例#28
0
 //Dropping objects -----------------------------------------------------------------------------------------------------
 public virtual void BuildDatabaseDropSql(DbObjectChange change, string name)
 {
     change.AddScript(DbScriptType.DatabaseDrop, "DROP DATABASE \"{0}\";", name);
 }
示例#29
0
        }//method

        //Analyzes changes in columns and keys, but not ref constraints
        private DbTableChangeGroup AnalyzeTableChanges(DbTableInfo oldTable)
        {
            var tableChangeGrp = new DbTableChangeGroup(oldTable, oldTable.Peer);

            if (oldTable.Peer == null)
            {
                //Table deleted -----------------------------------------------------------------------------------
                if (_dropUnknown)
                {
                    tableChangeGrp.Changes.Add(new DbObjectChange(oldTable, null, DbObjectChangeType.Drop));
                    //delete keys - all except primary key - it is deleted automatically with the table; foreign keys are deleted with constraints
                    foreach (var oldKey in oldTable.Keys)
                    {
                        _changedKeys.Add(oldKey);
                        if (!oldKey.KeyType.IsSet(KeyType.PrimaryKey | KeyType.ForeignKey))
                        {
                            tableChangeGrp.AddChange(oldKey, null);
                        }
                    }
                    foreach (var cmd in oldTable.CrudCommands)
                    {
                        tableChangeGrp.AddChange(cmd, null);
                    }
                }
                return(tableChangeGrp);
            }

            //Table/View modified? -----------------------------------------------------------------------------------
            var newTable = oldTable.Peer;

            if (_compareTables)
            {
                //Check table rename
                string descr;
                if (!NamesMatch(oldTable.TableName, oldTable.Peer.TableName))
                {
                    descr = string.Format("Renamed {0} to {1}", oldTable.TableName, oldTable.Peer.TableName);
                    var tableRename = new DbObjectChange(oldTable, oldTable.Peer, DbObjectChangeType.Rename, descr);
                    tableChangeGrp.Changes.Add(tableRename);
                }
                // Internals of the table or view
                switch (oldTable.Kind)
                {
                case EntityKind.View:
                    if (!ViewsMatch(oldTable, oldTable.Peer))
                    {
                        tableChangeGrp.AddChange(oldTable, null, DbObjectChangeType.Drop);
                        tableChangeGrp.AddChange(null, oldTable.Peer, DbObjectChangeType.Add);
                    }
                    break;

                case EntityKind.Table:
                    foreach (var oldCol in oldTable.Columns)
                    {
                        if (oldCol.Peer == null)
                        {
                            _changedColumns.Add(oldCol);
                            tableChangeGrp.AddChange(oldCol, null);
                        }
                        else
                        {
                            //Check column rename
                            if (!NamesMatch(oldCol.ColumnName, oldCol.Peer.ColumnName))
                            {
                                tableChangeGrp.AddChange(oldCol, oldCol.Peer, DbObjectChangeType.Rename);
                            }
                            if (!ColumnsMatch(oldCol, oldCol.Peer, out descr))
                            {
                                _changedColumns.Add(oldCol);
                                tableChangeGrp.AddChange(oldCol, oldCol.Peer, notes: descr);
                            }
                        }
                    } //foreach col
                    //new columns
                    foreach (var newCol in newTable.Columns)
                    {
                        if (newCol.Peer == null) //if not null - it is already taken care of
                        {
                            tableChangeGrp.AddChange(null, newCol);
                        }
                    }
                    break;
                } //switch oldTable.Kind
                 //Check table columns
            }     // if compareTables

            //Detect all changed keys, indexes; skip Foreign keys - they're not real keys
            // We do not modify keys, only drop/create them if anything mismatches;
            // key.Peer is set only if the keys did not change and non of the columns changed
            foreach (var key in oldTable.Keys)
            {
                bool changed = key.Peer == null || KeyChanged(key);
                if (!changed)
                {
                    continue;
                }
                _changedKeys.Add(key);
                if (key.KeyType.IsSet(KeyType.ForeignKey) || IsPureIndex(key) && !_compareIndexes)
                {
                    continue;
                }
                tableChangeGrp.AddChange(key, key.Peer);
            }
            foreach (var key in newTable.Keys)
            {
                if (key.Peer != null)
                {
                    continue; //if Peer != null, it is already included in previous loop
                }
                if (key.KeyType.IsSet(KeyType.ForeignKey) || IsPureIndex(key) && !_compareIndexes)
                {
                    continue;
                }
                tableChangeGrp.AddChange(null, key);
            }

            // CRUD stored procs
            if (_compareStoredProcs)
            {
                var oldUseProcs = _oldModel.Config.Options.IsSet(DbOptions.UseStoredProcs);
                var newUseProcs = _newModel.Config.Options.IsSet(DbOptions.UseStoredProcs);
                if (oldUseProcs || newUseProcs)
                {
                    var forceRebuildProcs = tableChangeGrp.Changes.Count > 0;
                    foreach (var cmd in newTable.CrudCommands)
                    {
                        if (cmd.CommandType != System.Data.CommandType.StoredProcedure)
                        {
                            continue;
                        }
                        if (cmd.Peer != null && StoredProceduresMatch(cmd.Peer, cmd))
                        {
                            continue;
                        }
                        tableChangeGrp.AddChange(cmd.Peer, cmd);
                    }
                } //if useProcs
                 // End table modified case ------------------------------------------------------------------------
            }     //stored procs
            return(tableChangeGrp);
        }
示例#30
0
 internal DbObjectChange AddChange(DbModelObjectBase oldObj, DbModelObjectBase newObj, DbObjectChangeType? changeType = null, string notes = null)
 {
     var change = new DbObjectChange(oldObj, newObj, changeType, notes);
       this.Changes.Add(change);
       return change;
 }
示例#31
0
 public override void BuildIndexDropSql(DbObjectChange change, DbKeyInfo key)
 {
     change.AddScript(DbScriptType.IndexDrop, "DROP INDEX \"{0}\".\"{1}\";", key.Table.Schema, key.Name);
 }
示例#32
0
        }//method

        //Analyzes changes in columns and keys, but not ref constraints
        private DbTableChangeGroup AnalyzeTableChanges(DbTableInfo oldTable)
        {
            var tableChangeGrp = new DbTableChangeGroup(oldTable, oldTable.Peer);

            if (oldTable.Peer == null)
            {
                //Table deleted -----------------------------------------------------------------------------------
                if (_dropUnknown)
                {
                    tableChangeGrp.Changes.Add(new DbObjectChange(oldTable, null, DbObjectChangeType.Drop));
                    //delete keys - all except primary key - it is deleted automatically with the table; foreign keys are deleted with constraints
                    foreach (var oldKey in oldTable.Keys)
                    {
                        _changedKeys.Add(oldKey);
                        if (!oldKey.KeyType.IsSet(KeyType.PrimaryKey | KeyType.ForeignKey))
                        {
                            tableChangeGrp.AddChange(oldKey, null);
                        }
                    }
                }
                return(tableChangeGrp);
            }

            //Table/View modified? -----------------------------------------------------------------------------------
            var newTable = oldTable.Peer;

            if (_compareTables)
            {
                //Check table rename
                string descr;
                if (!NamesMatch(oldTable.TableName, oldTable.Peer.TableName))
                {
                    descr = string.Format("Renamed {0} to {1}", oldTable.TableName, oldTable.Peer.TableName);
                    var tableRename = new DbObjectChange(oldTable, oldTable.Peer, DbObjectChangeType.Rename, descr);
                    tableChangeGrp.Changes.Add(tableRename);
                }
                // Internals of the table or view
                switch (oldTable.Kind)
                {
                case EntityKind.View:
                    if (_compareViews && !ViewsMatch(oldTable, oldTable.Peer))
                    {
                        tableChangeGrp.AddChange(oldTable, null, DbObjectChangeType.Drop);
                        tableChangeGrp.AddChange(null, oldTable.Peer, DbObjectChangeType.Add);
                    }
                    break;

                case EntityKind.Table:
                    foreach (var oldCol in oldTable.Columns)
                    {
                        if (oldCol.Peer == null)
                        {
                            oldCol.Flags |= DbColumnFlags.IsChanging;
                            tableChangeGrp.AddChange(oldCol, null);
                        }
                        else
                        {
                            //Check column rename
                            if (!NamesMatch(oldCol.ColumnName, oldCol.Peer.ColumnName))
                            {
                                tableChangeGrp.AddChange(oldCol, oldCol.Peer, DbObjectChangeType.Rename);
                            }
                            if (!_comparer.ColumnsMatch(oldCol, oldCol.Peer, out descr))
                            {
                                oldCol.Flags |= DbColumnFlags.IsChanging;
                                tableChangeGrp.AddChange(oldCol, oldCol.Peer, notes: descr);
                            }
                        }
                    } //foreach col
                    //new columns
                    foreach (var newCol in newTable.Columns)
                    {
                        if (newCol.Peer == null) //if not null - it is already taken care of
                        {
                            tableChangeGrp.AddChange(null, newCol);
                        }
                    }
                    break;
                } //switch oldTable.Kind
                 //Check table columns
            }     // if compareTables

            //Detect all changed keys, indexes; skip Foreign keys - they're not real keys
            // We do not modify keys, only drop/create them if anything mismatches;
            // key.Peer is set only if the keys did not change and non of the columns changed
            foreach (var oldKey in oldTable.Keys)
            {
                bool changed = oldKey.Peer == null || !_comparer.KeysMatch(oldKey, oldKey.Peer);
                if (!changed)
                {
                    continue;
                }
                _changedKeys.Add(oldKey);
                if (oldKey.KeyType.IsSet(KeyType.ForeignKey) || IsPureIndex(oldKey) && !_compareIndexes)
                {
                    continue;
                }
                tableChangeGrp.AddChange(oldKey, oldKey.Peer);
            }
            foreach (var key in newTable.Keys)
            {
                if (key.Peer != null)
                {
                    continue; //if Peer != null, it is already included in previous loop
                }
                //ignore primary key on Views - this is artificial attribute, used on CLR side only
                if (newTable.Kind == EntityKind.View && key.KeyType.IsSet(KeyType.PrimaryKey))
                {
                    continue;
                }
                if (key.KeyType.IsSet(KeyType.ForeignKey) || IsPureIndex(key) && !_compareIndexes)
                {
                    continue;
                }
                tableChangeGrp.AddChange(null, key);
            }

            return(tableChangeGrp);
        }
示例#33
0
 public override void BuildPrimaryKeyAddSql(DbObjectChange change, DbKeyInfo key)
 {
     base.BuildPrimaryKeyAddSql(change, key);
       if(key.KeyType.IsSet(KeyType.Clustered))
     change.AddScript(DbScriptType.PrimaryKeyAdd, "ALTER TABLE {0} CLUSTER ON \"{1}\";", key.Table.FullName, key.Name);
 }
示例#34
0
 public virtual void BuildDatabaseAddSql(DbObjectChange change, string name)
 {
     change.AddScript(DbScriptType.DatabaseAdd, "CREATE DATABASE \"{0}\"", name);
 }
示例#35
0
 public virtual void BuildColumnSetDefaultValuesSql(DbObjectChange change, DbColumnInfo column)
 {
     var fullTableRef = column.Table.FullName;
       change.AddScript(DbScriptType.ColumnInit, "UPDATE {0} SET \"{1}\" = {2} WHERE \"{1}\" IS NULL;",
     fullTableRef, column.ColumnName, column.TypeInfo.InitExpression);
 }