public void Visit_with_alter_column_operation_drops_default_constraint()
{
var modelBuilder = new BasicModelBuilder();
modelBuilder.Entity("A",
b =>
{
b.Property <int>("Id");
b.Property <string>("P").ForSqlServer().DefaultExpression("abc");
b.Key("Id");
});
var alterColumnOperation
= new AlterColumnOperation(
"A",
new Column("P", typeof(int)), true);
var operations = PreProcess(modelBuilder, alterColumnOperation);
Assert.Equal(2, operations.Count);
Assert.IsType <DropDefaultConstraintOperation>(operations[0]);
Assert.Same(alterColumnOperation, operations[1]);
var dropDefaultConstraintOperation = (DropDefaultConstraintOperation)operations[0];
Assert.Same("P", dropDefaultConstraintOperation.ColumnName);
}
public void Visit_with_alter_column_operation_resets_primary_key()
{
var modelBuilder = new BasicModelBuilder();
modelBuilder.Entity("A",
b =>
{
b.Property <string>("Id");
b.Key("Id");
});
var alterColumnOperation
= new AlterColumnOperation(
"A",
new Column("Id", typeof(int))
{
IsNullable = false
},
true);
var operations = PreProcess(modelBuilder, alterColumnOperation);
Assert.Equal(3, operations.Count);
Assert.IsType <DropPrimaryKeyOperation>(operations[0]);
Assert.Same(alterColumnOperation, operations[1]);
Assert.IsType <AddPrimaryKeyOperation>(operations[2]);
var dropPrimaryKeyOperation = (DropPrimaryKeyOperation)operations[0];
var addPrimaryKeyOperation = (AddPrimaryKeyOperation)operations[2];
Assert.Equal("PK_A", dropPrimaryKeyOperation.PrimaryKeyName);
Assert.Equal("PK_A", addPrimaryKeyOperation.PrimaryKeyName);
Assert.Equal(new[] { "Id" }, addPrimaryKeyOperation.ColumnNames);
}
public void Visit_with_alter_column_operation_resets_indexes()
{
var modelBuilder = new BasicModelBuilder();
modelBuilder.Entity("A",
b =>
{
b.Property <int>("Id");
b.Property <string>("P");
b.Key("Id");
b.Index("P");
});
var alterColumnOperation
= new AlterColumnOperation(
"A",
new Column("P", typeof(int)), true);
var operations = PreProcess(modelBuilder, alterColumnOperation);
Assert.Equal(3, operations.Count);
Assert.IsType <DropIndexOperation>(operations[0]);
Assert.Same(alterColumnOperation, operations[1]);
Assert.IsType <CreateIndexOperation>(operations[2]);
var dropIndexOperation = (DropIndexOperation)operations[0];
var createIndexOperation = (CreateIndexOperation)operations[2];
Assert.Equal("IX_A_P", dropIndexOperation.IndexName);
Assert.Equal("IX_A_P", createIndexOperation.IndexName);
Assert.Equal(new[] { "P" }, createIndexOperation.ColumnNames);
}
public void Visit_with_alter_column_does_not_reset_indexes_if_same_type_but_smaller_max_length()
{
var database = new DatabaseModel();
var column
= new Column("Id", typeof(string))
{
MaxLength = 10
};
var table = new Table("A", new[] { column });
var index = new Index("IX", new[] { column });
database.AddTable(table);
table.AddIndex(index);
var alterColumnOperation
= new AlterColumnOperation(
"A",
new Column("Id", typeof(string))
{
MaxLength = 9
}, true);
var operations = PreProcess(database, alterColumnOperation);
Assert.Equal(1, operations.Count);
Assert.Same(alterColumnOperation, operations[0]);
}
public void Visit_with_alter_column_operation_and_timestamp_column()
{
var database = new DatabaseModel();
var column0
= new Column("Id", typeof(byte[]))
{
IsTimestamp = true
};
var column1 = new Column("P", typeof(string));
var table = new Table("A", new[] { column0, column1 });
database.AddTable(table);
var alterColumnOperation
= new AlterColumnOperation(
"A",
new Column("Id", typeof(byte[])), true);
var operations = PreProcess(database, alterColumnOperation);
Assert.Equal(2, operations.Count);
Assert.IsType <DropColumnOperation>(operations[0]);
Assert.IsType <AddColumnOperation>(operations[1]);
var dropColumnOperation = (DropColumnOperation)operations[0];
var addColumnOperation = (AddColumnOperation)operations[1];
Assert.Equal("Id", dropColumnOperation.ColumnName);
Assert.Equal("Id", addColumnOperation.Column.Name);
Assert.False(addColumnOperation.Column.IsTimestamp);
}
public static OperationBuilderSurface <AlterColumnOperation> AlterColumn <T>(this IMigrationBuilder builder, string name, string table, string schema = null, string catalog = null,
string storeType = null, bool?unicode = null, int?size = null, int?precision = null, bool nullable = false,
object defaultValue = null, string defaultValueSql = null, string computedColumnExpression = null,
string collationName = null, DbType?explicitDbType = null)
{
var op = new AlterColumnOperation
{
Column = new ColumnDefinition
{
Name = new SubObjectName {
Catalog = catalog, ParentName = table, Name = name, Schema = schema
},
Type = ColumnDefinition.InferType(explicitDbType, typeof(T), storeType, size, precision),
DefaultValue = defaultValue,
IsNullable = nullable,
Unicode = unicode,
DefaultValueSql = defaultValueSql,
ComputedColumnExpressionSql = computedColumnExpression,
CollationName = null,
}
};
builder.AddOperation(op);
return(new OperationBuilderSurface <AlterColumnOperation>(op));
}
protected override void Generate(AlterColumnOperation alterColumnOperation)
{
// Делаем себе возможность избавиться от регистронезависимости
base.Generate(alterColumnOperation);
AnnotationValues values;
if (alterColumnOperation.Column.Annotations.TryGetValue("CaseSensitive", out values))
{
if (values.NewValue != null && values.NewValue.ToString() == "True")
{
using (var writer = Writer())
{
var columnSQL = BuildColumnType(alterColumnOperation.Column);
writer.WriteLine(
"ALTER TABLE {0} ALTER COLUMN {1} {2} COLLATE SQL_Latin1_General_CP1_CS_AS {3}",
alterColumnOperation.Table,
alterColumnOperation.Column.Name,
columnSQL,
alterColumnOperation.Column.IsNullable.HasValue == false || alterColumnOperation.Column.IsNullable.Value == true ? " NULL" : "NOT NULL"
);
Statement(writer);
}
}
}
}
public void Visit_with_alter_column_operation_resets_unique_constraints_on_column()
{
var modelBuilder = new BasicModelBuilder();
modelBuilder.Entity("A",
b =>
{
b.Property <int>("Id");
var p = b.Property <string>("P").Metadata;
b.Key("Id");
b.Metadata.AddKey(p);
});
var alterColumnOperation
= new AlterColumnOperation(
"A",
new Column("P", typeof(int)), true);
var operations = PreProcess(modelBuilder, alterColumnOperation);
Assert.Equal(3, operations.Count);
Assert.IsType <DropUniqueConstraintOperation>(operations[0]);
Assert.Same(alterColumnOperation, operations[1]);
Assert.IsType <AddUniqueConstraintOperation>(operations[2]);
var dropUniqueConstraintOperation = (DropUniqueConstraintOperation)operations[0];
var addUniqueConstraintOperation = (AddUniqueConstraintOperation)operations[2];
Assert.Equal("UC_A_P", dropUniqueConstraintOperation.UniqueConstraintName);
Assert.Equal("UC_A_P", addUniqueConstraintOperation.UniqueConstraintName);
Assert.Equal(new[] { "P" }, addUniqueConstraintOperation.ColumnNames);
}
/// <summary>
/// 修改列。
/// </summary>
/// <typeparam name="TEntity">实体类型。</typeparam>
/// <param name="type">字段类型。</param>
/// <param name="unicode">是否为Unicode编码。</param>
/// <param name="column">列表达式。</param>
/// <param name="nullable">是否为空。</param>
/// <param name="defaultValue">默认值。</param>
/// <param name="defaultValueSql">默认值SQL字符串。</param>
/// <param name="computedColumnSql">计算列的SQL字符串。</param>
/// <returns>返回操作实例。</returns>
public virtual AlterOperationBuilder <AlterColumnOperation> AlterColumn <TEntity>(
Expression <Func <TEntity, object> > column,
string type = null,
bool?unicode = null,
bool?nullable = null,
object defaultValue = null,
string defaultValueSql = null,
string computedColumnSql = null)
{
Check.NotNull(column, nameof(column));
var property = typeof(TEntity).GetEntityType().FindProperty(column.GetPropertyAccess().Name);
var operation = new AlterColumnOperation
{
Table = typeof(TEntity).GetTableName(),
Name = property.Name,
ClrType = property.ClrType,
ColumnType = type,
IsUnicode = unicode,
IsIdentity = property.IsIdentity,
MaxLength = property.MaxLength,
IsRowVersion = property.IsRowVersion,
IsNullable = nullable ?? property.IsNullable,
DefaultValue = defaultValue,
DefaultValueSql = defaultValueSql,
ComputedColumnSql = computedColumnSql
};
Operations.Add(operation);
return(new AlterOperationBuilder <AlterColumnOperation>(operation));
}
protected virtual void Generate(
[NotNull] AlterColumnOperation operation,
[CanBeNull] IModel model,
[NotNull] MigrationCommandListBuilder builder)
{
throw new NotImplementedException();
}
public virtual OperationBuilder <AlterColumnOperation> AlterColumn(
[NotNull] string name,
[NotNull] string table,
[NotNull] string type,
[CanBeNull] string schema = null,
bool nullable = false,
[CanBeNull] object defaultValue = null,
[CanBeNull] string defaultValueSql = null,
[CanBeNull] string computedColumnSql = null)
{
Check.NotEmpty(name, nameof(name));
Check.NotEmpty(table, nameof(table));
var operation = new AlterColumnOperation
{
Schema = schema,
Table = table,
Name = name,
Type = type,
IsNullable = nullable,
DefaultValue = defaultValue,
DefaultValueSql = defaultValueSql,
ComputedColumnSql = computedColumnSql
};
Operations.Add(operation);
return(new OperationBuilder <AlterColumnOperation>(operation));
}
public void Process_with_alter_column_operation_drops_default_constraint()
{
var sourceModel = new Model();
var sourceModelBuilder = new BasicModelBuilder(sourceModel);
sourceModelBuilder.Entity("A",
b =>
{
b.Property <int>("Id");
b.Property <string>("P").ForSqlServer().DefaultExpression("abc");
b.Key("Id");
});
var inOperations = new MigrationOperationCollection();
var alterColumnOperation
= new AlterColumnOperation(
"A",
new Column("P", typeof(int)),
isDestructiveChange: false);
inOperations.Add(alterColumnOperation);
var operations = Process(inOperations, sourceModel);
Assert.Equal(2, operations.Count);
Assert.IsType <DropDefaultConstraintOperation>(operations[0]);
Assert.Same(alterColumnOperation, operations[1]);
var dropDefaultConstraintOperation = (DropDefaultConstraintOperation)operations[0];
Assert.Same("P", dropDefaultConstraintOperation.ColumnName);
}
/// <summary>
/// Generates a migration operation to drpo an existing primary key.
/// </summary>
/// <param name="op">The operation that represents dropping an existing primary key.</param>
/// <returns>A migration operation to drop an existing primary key.</returns>
protected virtual MigrationStatement Generate(DropPrimaryKeyOperation op)
{
object obj2;
bool deleteAutoIncrement = false;
StringBuilder sb = new StringBuilder();
op.AnonymousArguments.TryGetValue("DeleteAutoIncrement", out obj2);
if (obj2 != null)
{
bool.TryParse(obj2.ToString(), out deleteAutoIncrement);
}
if (deleteAutoIncrement && op.Columns.Count == 1)
{
var newColumn = new ColumnModel(PrimitiveTypeKind.Int32, null);
newColumn.Name = op.Columns[0];
var alterColumn = new AlterColumnOperation(op.Table, newColumn, false);
var ms = Generate(alterColumn);
sb.Append(ms.Sql + "; ");
}
return(new MigrationStatement {
Sql = sb.ToString() + " alter table `" + op.Table + "` drop primary key "
});
}
/// <summary>
/// Generates a migration operation to alter a column.
/// </summary>
/// <param name="op">The operation that represents altering an existing column.</param>
/// <returns>A migration operation to alter a column.</returns>
protected virtual MigrationStatement Generate(AlterColumnOperation op)
{
if (op == null)
{
return(null);
}
ColumnModel column = op.Column;
StringBuilder sb = new StringBuilder();
_tableName = op.Table;
//verify if there is any "AddPrimaryKeyOperation" related with the column that will be added and if it is defined as identity (auto_increment)
bool uniqueAttr = (from pkOpe in _pkOperations
where (from col in pkOpe.Columns
where col == op.Column.Name
select col).Count() > 0
select pkOpe).Count() > 0 & op.Column.IsIdentity;
// for existing columns
sb.Append("alter table `" + TrimSchemaPrefix(op.Table) + "` modify `" + column.Name + "` ");
// add definition
sb.Append(Generate(column) + (uniqueAttr ? " unique " : ""));
return(new MigrationStatement {
Sql = sb.ToString()
});
}
protected override void Generate(AlterColumnOperation alterColumnOperation)
{
string tableName = getNameWithReplacedSchema(alterColumnOperation.Table);
var newAlterColumnOperation = new AlterColumnOperation(tableName, alterColumnOperation.Column, alterColumnOperation.IsDestructiveChange);
base.Generate(newAlterColumnOperation);
}
protected override void Generate(AlterColumnOperation operation, IModel model, MigrationCommandListBuilder builder)
{
ThrowIf.Argument.IsNull(operation, "AlterColumnOperation");
ThrowIf.Argument.IsNull(model, "model");
ThrowIf.Argument.IsNull(builder, "builder");
var operationColumn = new AddColumnOperation();
operationColumn.Schema = operation.Schema;
operationColumn.Table = operation.Table;
operationColumn.Name = operation.Name;
operationColumn.ClrType = operation.ClrType;
operationColumn.ColumnType = operation.ColumnType;
operationColumn.ComputedColumnSql = operation.ComputedColumnSql;
operationColumn.DefaultValue = operation.DefaultValue;
operationColumn.DefaultValueSql = operation.DefaultValueSql;
builder
.Append("ALTER TABLE " + operation.Table)
.Append(" MODIFY ");
ColumnDefinition(operationColumn, model, builder);
builder
.AppendLine(_sqlGenerationHelper.StatementTerminator);
EndStatement(builder);
}
/// <inheritdoc />
protected override void Generate(AlterColumnOperation operation, IModel model, MigrationCommandListBuilder builder)
{
base.Generate(operation, model, builder);
var oldComment = GetComment(operation.OldColumn);
var comment = GetComment(operation);
if (oldComment != comment)
{
builder.AppendLine(Dependencies.SqlGenerationHelper.StatementTerminator);
var dropDescription = oldComment != null;
if (dropDescription)
{
DropDescription(
builder,
operation.Schema,
operation.Table,
operation.Name);
}
if (comment != null)
{
AddDescription(
builder,
comment,
operation.Schema,
operation.Table,
operation.Name,
omitSchemaVariable: dropDescription);
}
builder.EndCommand(suppressTransaction: IsMemoryOptimized(operation, model, operation.Schema, operation.Table));
}
}
protected override void Generate(AlterColumnOperation alterColumnOperation)
{
base.Generate(alterColumnOperation);
AnnotationValues values;
if (alterColumnOperation.Column.Annotations.TryGetValue("CaseSensitive", out values))
{
if (values.NewValue != null && values.NewValue.ToString() == "True")
{
using (var writer = Writer())
{
if (alterColumnOperation.Column.IsNullable.HasValue && !alterColumnOperation.Column.IsNullable.Value)
{
writer.WriteLine(
"ALTER TABLE {0} ALTER COLUMN {1} NVARCHAR({2}) COLLATE SQL_Latin1_General_CP1_CS_AS NOT NULL",
alterColumnOperation.Table,
alterColumnOperation.Column.Name,
alterColumnOperation.Column.MaxLength);
}
else
{
writer.WriteLine(
"ALTER TABLE {0} ALTER COLUMN {1} NVARCHAR({2}) COLLATE SQL_Latin1_General_CP1_CS_AS NULL",
alterColumnOperation.Table,
alterColumnOperation.Column.Name,
alterColumnOperation.Column.MaxLength);
}
Statement(writer);
}
}
}
}
private void Generate(AlterColumnOperation migration)
{
using (var writer = Writer())
{
// create initial SQL
var sql = string.Format("ALTER TABLE {0} ALTER COLUMN ",
Name(migration.Table));
writer.Write(sql);
// generate the column name and type part
var column = migration.Column;
Generate(column, writer, true);
// end the column type
writer.Write(";");
if (column.IsNullable != null)
{
// create a new row to set nullable
writer.Write(sql);
writer.Write(Quote(column.Name));
writer.Write(" {0} NOT NULL;", column.IsNullable == true ? "DROP" : "SET");
}
Statement(writer);
}
}
public override void Visit(AlterColumnOperation alterColumnOperation, Context context)
{
Check.NotNull(alterColumnOperation, "alterColumnOperation");
Check.NotNull(context, "context");
var compositeOperation
= context.CompositeOperation as CompositeAlterColumnOperation
?? new CompositeAlterColumnOperation();
var database = context.Generator.Database;
var table = database.GetTable(alterColumnOperation.TableName);
var column = table.GetColumn(alterColumnOperation.NewColumn.Name);
var newColumn = alterColumnOperation.NewColumn;
string dataType, newDataType;
GetDataTypes(table, column, newColumn, context, out dataType, out newDataType);
if (table.PrimaryKey != null &&
table.PrimaryKey.Columns.Any(c => ReferenceEquals(c, column)))
{
compositeOperation.AddPrimaryKey(table.PrimaryKey);
}
compositeOperation.AddForeignKeys(
table.ForeignKeys
.Where(fk => fk.Columns.Any(c => ReferenceEquals(c, column))));
compositeOperation.AddForeignKeys(
database.Tables
.SelectMany(t => t.ForeignKeys)
.Where(fk => fk.ReferencedColumns.Any(c => ReferenceEquals(c, column))));
if (dataType != newDataType ||
((string.Equals(dataType, "varchar", StringComparison.OrdinalIgnoreCase) ||
string.Equals(dataType, "nvarchar", StringComparison.OrdinalIgnoreCase) ||
string.Equals(dataType, "varbinary", StringComparison.OrdinalIgnoreCase)) &&
newColumn.MaxLength > column.MaxLength))
{
compositeOperation.AddIndexes(
table.Indexes
.Where(ix => ix.Columns.Any(c => ReferenceEquals(c, column))));
}
if (column.HasDefault)
{
compositeOperation.AddOperation(new DropDefaultConstraintOperation(table.Name, column.Name));
}
if (column.IsTimestamp)
{
compositeOperation.AddOperation(new DropColumnOperation(table.Name, column.Name));
compositeOperation.AddOperation(new AddColumnOperation(table.Name, newColumn));
}
else
{
compositeOperation.AddOperation(alterColumnOperation);
}
context.ProcessCompositeOperation(compositeOperation);
}
public void Process_with_alter_column_does_not_reset_indexes_if_same_type_but_smaller_max_length()
{
var sourceModel = new Model();
var sourceModelBuilder = new BasicModelBuilder(sourceModel);
sourceModelBuilder.Entity("A",
b =>
{
b.Property <string>("Id").MaxLength(10);
b.Key("Id");
b.Index("Id").ForSqlServer().Name("IX");
});
var inOperations = new MigrationOperationCollection();
var alterColumnOperation
= new AlterColumnOperation(
"A",
new Column("Id", typeof(string))
{
MaxLength = 9
},
isDestructiveChange: false);
inOperations.Add(alterColumnOperation);
var operations = Process(inOperations, sourceModel);
Assert.Equal(3, operations.Count);
Assert.IsType <DropPrimaryKeyOperation>(operations[0]);
Assert.Same(alterColumnOperation, operations[1]);
Assert.IsType <AddPrimaryKeyOperation>(operations[2]);
}
/// <summary>
/// 修改列。
/// </summary>
/// <param name="type">字段类型。</param>
/// <param name="unicode">是否为Unicode编码。</param>
/// <param name="table">表格名称。</param>
/// <param name="name">字段。</param>
/// <param name="nullable">是否为空。</param>
/// <param name="identity">是否为自增长。</param>
/// <param name="defaultValue">默认值。</param>
/// <param name="defaultValueSql">默认值SQL字符串。</param>
/// <param name="computedColumnSql">计算列的SQL字符串。</param>
/// <returns>返回操作实例。</returns>
public virtual AlterOperationBuilder <AlterColumnOperation> AlterColumn(
string table,
string name,
string type = null,
bool?unicode = null,
bool?nullable = true,
bool identity = false,
object defaultValue = null,
string defaultValueSql = null,
string computedColumnSql = null)
{
Check.NotNull(name, nameof(name));
var operation = new AlterColumnOperation
{
Table = table,
Name = name,
ColumnType = type,
IsUnicode = unicode,
IsIdentity = identity,
IsNullable = nullable,
DefaultValue = defaultValue,
DefaultValueSql = defaultValueSql,
ComputedColumnSql = computedColumnSql
};
Operations.Add(operation);
return(new AlterOperationBuilder <AlterColumnOperation>(operation));
}
protected override void Generate(AlterColumnOperation alterColumnOperation)
{
base.Generate(alterColumnOperation);
AnnotationValues values;
if (alterColumnOperation.Column.Annotations.TryGetValue("CaseSensitive", out values))
{
if (values.NewValue != null && values.NewValue.ToString() == "True")
{
using (var writer = Writer())
{
//if (System.Diagnostics.Debugger.IsAttached == false) System.Diagnostics.Debugger.Launch();
// https://github.com/mono/entityframework/blob/master/src/EntityFramework.SqlServer/SqlServerMigrationSqlGenerator.cs
var columnSQL = BuildColumnType(alterColumnOperation.Column); //[nvarchar](100)
writer.WriteLine(
"ALTER TABLE {0} ALTER COLUMN {1} {2} COLLATE SQL_Latin1_General_CP1_CS_AS {3}",
alterColumnOperation.Table,
alterColumnOperation.Column.Name,
columnSQL,
alterColumnOperation.Column.IsNullable.HasValue == false || alterColumnOperation.Column.IsNullable.Value == true ? " NULL" : "NOT NULL" //todo not tested for DefaultValue
);
Statement(writer);
}
}
}
}
protected virtual void Generate([NotNull] AlterColumnOperation operation, [NotNull] IndentedStringBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
builder.AppendLine(".AlterColumn(");
using (builder.Indent())
{
builder
.Append("name: ")
.Append(_code.Literal(operation.Name));
if (operation.Schema != null)
{
builder
.AppendLine(",")
.Append("schema: ")
.Append(_code.Literal(operation.Schema));
}
builder
.AppendLine(",")
.Append("table: ")
.Append(_code.Literal(operation.Table))
.AppendLine(",")
.Append("type: ")
.Append(_code.Literal(operation.Type))
.AppendLine(",")
.Append("nullable: ")
.Append(_code.Literal(operation.IsNullable));
if (operation.DefaultValueSql != null)
{
builder
.AppendLine(",")
.Append("defaultValueSql: ")
.Append(_code.Literal(operation.DefaultValueSql));
}
else if (operation.ComputedColumnSql != null)
{
builder
.AppendLine(",")
.Append("computedColumnSql: ")
.Append(_code.UnknownLiteral(operation.ComputedColumnSql));
}
else if (operation.DefaultValue != null)
{
builder
.AppendLine(",")
.Append("defaultValue: ")
.Append(_code.UnknownLiteral(operation.DefaultValue));
}
builder.Append(")");
Annotations(operation.Annotations, builder);
}
}
private void DropMaskingFunction(AlterColumnOperation operation, MigrationCommandListBuilder builder)
{
builder.Append("ALTER TABLE ")
.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Table, operation.Schema))
.Append($" ALTER COLUMN {operation.Name}")
.Append($" DROP MASKED")
.EndCommand();
}
private void AppendAlterColumn(AlterColumnOperation alterColumnOperation, StringBuilder sql)
{
sql.Append("ALTER TABLE ");
AppendTableName(alterColumnOperation.Table, sql);
sql.Append(" ALTER COLUMN \"");
sql.Append(alterColumnOperation.Column.Name);
sql.Append('"');
}
public virtual void Visit(AlterColumnOperation alterColumnOperation, DatabaseModel databaseModel)
{
var table = databaseModel.GetTable(alterColumnOperation.TableName);
var newColumn = alterColumnOperation.NewColumn;
var column = table.GetColumn(newColumn.Name);
column.Copy(newColumn);
}
protected virtual IEnumerable <MigrationOperation> Diff([NotNull] IProperty source, [NotNull] IProperty target)
{
var sourceAnnotations = Annotations.For(source);
var sourceEntityTypeAnnotations = Annotations.For(source.DeclaringEntityType.RootType());
var targetAnnotations = Annotations.For(target);
if (sourceAnnotations.ColumnName != targetAnnotations.ColumnName)
{
yield return(new RenameColumnOperation
{
Schema = sourceEntityTypeAnnotations.Schema,
Table = sourceEntityTypeAnnotations.TableName,
Name = sourceAnnotations.ColumnName,
NewName = targetAnnotations.ColumnName
});
}
var sourceColumnType = sourceAnnotations.ColumnType
?? TypeMapper.GetMapping(source).DefaultTypeName;
var targetColumnType = targetAnnotations.ColumnType
?? TypeMapper.GetMapping(target).DefaultTypeName;
var targetMigrationsAnnotations = MigrationsAnnotations.For(target);
var isSourceColumnNullable = source.IsColumnNullable();
var isTargetColumnNullable = target.IsColumnNullable();
var isNullableChanged = isSourceColumnNullable != isTargetColumnNullable;
var columnTypeChanged = sourceColumnType != targetColumnType;
if (isNullableChanged ||
columnTypeChanged ||
sourceAnnotations.DefaultValueSql != targetAnnotations.DefaultValueSql ||
sourceAnnotations.ComputedValueSql != targetAnnotations.ComputedValueSql ||
!Equals(sourceAnnotations.DefaultValue, targetAnnotations.DefaultValue) ||
HasDifferences(MigrationsAnnotations.For(source), targetMigrationsAnnotations))
{
var isDestructiveChange = (isNullableChanged && isSourceColumnNullable)
// TODO: Detect type narrowing
|| columnTypeChanged;
var alterColumnOperation = new AlterColumnOperation
{
Schema = sourceEntityTypeAnnotations.Schema,
Table = sourceEntityTypeAnnotations.TableName,
Name = sourceAnnotations.ColumnName,
ClrType = target.ClrType.UnwrapNullableType().UnwrapEnumType(),
ColumnType = targetAnnotations.ColumnType,
IsNullable = isTargetColumnNullable,
DefaultValue = targetAnnotations.DefaultValue,
DefaultValueSql = targetAnnotations.DefaultValueSql,
ComputedColumnSql = targetAnnotations.ComputedValueSql,
IsDestructiveChange = isDestructiveChange
};
CopyAnnotations(targetMigrationsAnnotations, alterColumnOperation);
yield return(alterColumnOperation);
}
}
public virtual AlterOperationBuilder <AlterColumnOperation> AlterColumn(
string name,
string table,
Type clrType,
string type = null,
bool?unicode = null,
int?maxLength = null,
bool rowVersion = false,
string schema = null,
bool nullable = false,
object defaultValue = null,
string defaultValueSql = null,
string computedColumnSql = null,
Type oldClrType = null,
string oldType = null,
bool?oldUnicode = null,
int?oldMaxLength = null,
bool oldRowVersion = false,
bool oldNullable = false,
object oldDefaultValue = null,
string oldDefaultValueSql = null,
string oldComputedColumnSql = null)
{
Check.NotEmpty(name, nameof(name));
Check.NotEmpty(table, nameof(table));
var operation = new AlterColumnOperation
{
Schema = schema,
Table = table,
Name = name,
ClrType = clrType,
ColumnType = type,
IsUnicode = unicode,
MaxLength = maxLength,
IsRowVersion = rowVersion,
IsNullable = nullable,
DefaultValue = defaultValue,
DefaultValueSql = defaultValueSql,
ComputedColumnSql = computedColumnSql,
OldColumn = new ColumnOperation
{
ClrType = oldClrType ?? clrType,
ColumnType = oldType,
IsUnicode = oldUnicode,
MaxLength = oldMaxLength,
IsRowVersion = oldRowVersion,
IsNullable = oldNullable,
DefaultValue = oldDefaultValue,
DefaultValueSql = oldDefaultValueSql,
ComputedColumnSql = oldComputedColumnSql
}
};
Operations.Add(operation);
return(new AlterOperationBuilder <AlterColumnOperation>(operation));
}
/// <summary>
/// Generates SQL for a <see cref="AlterColumnOperation" />.
/// Generated SQL should be added using the Statement method.
/// </summary>
/// <param name="alterColumnOperation"> The operation to produce SQL for. </param>
protected virtual void Generate(AlterColumnOperation alterColumnOperation)
{
Check.NotNull(alterColumnOperation, "alterColumnOperation");
var column = alterColumnOperation.Column;
using (var writer = Writer())
{
writer.Write("ALTER TABLE ");
writer.Write(Name(alterColumnOperation.Table));
writer.Write(" ALTER COLUMN ");
writer.Write(Quote(column.Name));
writer.Write(" ");
writer.Write(BuildColumnType(column));
if ((column.IsNullable != null)
&& !column.IsNullable.Value)
{
writer.Write(" NOT");
}
writer.Write(" NULL");
Statement(writer);
}
if ((column.DefaultValue != null)
|| !string.IsNullOrWhiteSpace(column.DefaultValueSql))
{
using (var writer = Writer())
{
writer.Write("ALTER TABLE ");
writer.Write(Name(alterColumnOperation.Table));
writer.Write(" ALTER COLUMN ");
writer.Write(Quote(column.Name));
writer.Write(" DROP DEFAULT");
Statement(writer);
}
using (var writer = Writer())
{
writer.Write("ALTER TABLE ");
writer.Write(Name(alterColumnOperation.Table));
writer.Write(" ALTER COLUMN ");
writer.Write(Quote(column.Name));
writer.Write(" SET DEFAULT ");
writer.Write(
(column.DefaultValue != null)
? Generate((dynamic)column.DefaultValue)
: column.DefaultValueSql
);
Statement(writer);
}
}
}
