protected override void Generate(
RenameColumnOperation operation,
IModel model,
MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
var qualifiedName = new StringBuilder();
if (operation.Schema != null)
{
qualifiedName
.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Schema))
.Append(".");
}
qualifiedName.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Table));
builder
.Append("ALTER TABLE ")
.Append(qualifiedName)
.Append(" RENAME COLUMN ")
.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Name))
.Append(" TO ")
.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.NewName));
builder.EndCommand();
}
public virtual void Visit(RenameColumnOperation renameColumnOperation, DatabaseModel databaseModel)
{
var table = databaseModel.GetTable(renameColumnOperation.TableName);
var column = table.GetColumn(renameColumnOperation.ColumnName);
column.Name = renameColumnOperation.NewColumnName;
}
protected virtual void Generate([NotNull] RenameColumnOperation operation, [NotNull] IndentedStringBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
builder.AppendLine(".RenameColumn(");
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("newName: ")
.Append(_code.Literal(operation.NewName))
.Append(")");
Annotations(operation.Annotations, builder);
}
}
protected virtual void Generate(
[NotNull] RenameColumnOperation operation,
[CanBeNull] IModel model,
[NotNull] MigrationCommandListBuilder builder)
{
throw new NotImplementedException();
}
public void ShouldMergeWithUpdateTableOperationOnce()
{
var columns = new[]
{
Column.Int("ID", Nullable.NotNull, null, null, null),
Column.VarChar("Name", new CharacterLength(500), null, Nullable.NotNull, null, null, null),
};
var addTableOp = new AddTableOperation("skma", "Farmers", columns, false, null, null, null, new string[0]);
var updateNameColumnOp = new UpdateTableOperation("skma", "Farmers",
new[] { Column.VarChar("NAME", new CharacterLength(50), null, Nullable.NotNull, null, null, null) }, null,
null);
var updateZipColumnOp = new UpdateTableOperation("skma", "Farmers",
new[] { Column.VarChar("Zip", new CharacterLength(10), null, Nullable.Null, null, null, null) }, null, null);
var renameZipColumnOp = new RenameColumnOperation("skma", "Farmers", "ZIP", "ZipCode");
updateZipColumnOp.Merge(renameZipColumnOp);
updateNameColumnOp.Merge(renameZipColumnOp);
addTableOp.Merge(renameZipColumnOp);
updateNameColumnOp.Merge(updateZipColumnOp);
addTableOp.Merge(updateZipColumnOp);
addTableOp.Merge(updateNameColumnOp);
Assert.That(addTableOp.Disabled, Is.False);
Assert.That(updateNameColumnOp.Disabled, Is.True);
Assert.That(updateZipColumnOp.Disabled, Is.True);
Assert.That(renameZipColumnOp.Disabled, Is.True);
Assert.That(addTableOp.Columns.Count, Is.EqualTo(3));
Assert.That(addTableOp.Columns[0].Name, Is.EqualTo("ID"));
Assert.That(addTableOp.Columns[1].Name, Is.EqualTo("NAME"));
Assert.That(addTableOp.Columns[2].Name, Is.EqualTo("ZipCode"));
}
protected override void Generate(
[NotNull] RenameColumnOperation operation,
[CanBeNull] IModel model,
[NotNull] MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
var property = FindProperty(model, operation.Schema, operation.Table, operation.NewName);
if (property == null)
{
throw new InvalidOperationException($"Could not find column definition for table: '{Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Table, operation.Schema)}' column: {operation.Name}");
}
builder.Append("ALTER TABLE ")
.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Table, operation.Schema))
.Append(" CHANGE ")
.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Name))
.Append(" ")
.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.NewName))
.Append(" ")
.Append(property.Relational().ColumnType);
EndStatement(builder);
}
protected override void Generate(
[NotNull] RenameColumnOperation operation,
[CanBeNull] IModel model,
[NotNull] MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
var property = FindProperty(model, model.MySql().DefaultSchema, operation.Table, operation.NewName);
var type = TypeMapper.FindMapping(property).StoreType;
builder.Append("ALTER TABLE ")
.Append(SqlGenerationHelper.DelimitIdentifier(operation.Table, operation.Schema))
.Append(" CHANGE ")
.Append(SqlGenerationHelper.DelimitIdentifier(operation.Name))
.Append(" ")
.Append(SqlGenerationHelper.DelimitIdentifier(operation.NewName))
.Append(" ")
.Append(type);
if (!property.IsNullable)
{
builder.Append(" NOT NULL");
}
EndStatement(builder);
}
public void ShouldRenameColumnMultipleTimes()
{
var columns = new[]
{
Column.Int("c1", Nullable.NotNull, null, null, "description"),
};
var op = new AddTableOperation("schema", "table", columns, false, "file group", "textimagefilegroup", "filestreamfilegroup", new string[0]);
var renameColumn1Op = new RenameColumnOperation("SCHEMA", "TABLE", "C1", "C1New");
var renameColumn2Op = new RenameColumnOperation("SCHEMA", "TABLE", "C1New", "C2");
renameColumn1Op.Merge(renameColumn2Op);
op.Merge(renameColumn2Op);
op.Merge(renameColumn1Op);
Assert.That(renameColumn2Op.Disabled, Is.True);
Assert.That(renameColumn2Op.Name, Is.EqualTo("C1New"));
Assert.That(renameColumn2Op.NewName, Is.EqualTo("C2"));
Assert.That(renameColumn1Op.Disabled, Is.True);
Assert.That(renameColumn1Op.Name, Is.EqualTo("C1"));
Assert.That(renameColumn1Op.NewName, Is.EqualTo("C2"));
Assert.That(op.Disabled, Is.False);
Assert.That(op.Columns[0].Name, Is.EqualTo("C2"));
}
public void ShouldNotRenameTableIfTableIsRenamedAfterColumnsAreRenamed()
{
var columns = new[]
{
Column.Int("c1", Nullable.NotNull, null, null, "description"),
Column.VarChar("c2", new CharacterLength(1008), "collation", Nullable.NotNull, null, null, "description")
};
var op = new AddTableOperation("schema", "table", columns, false, "file group", "textimagefilegroup", "filestreamfilegroup", new string[0]);
var renameColumn1Op = new RenameColumnOperation("SCHEMA", "TABLE", "C1", "C1New");
var renameColumn2Op = new RenameColumnOperation("SCHEMA", "TABLE", "C2", "C2New");
var renameTableOp = new RenameObjectOperation("SCHEMA", "TABLE", "T1New");
renameColumn2Op.Merge(renameTableOp);
renameColumn1Op.Merge(renameTableOp);
op.Merge(renameTableOp);
renameColumn1Op.Merge(renameColumn2Op);
op.Merge(renameColumn2Op);
op.Merge(renameColumn1Op);
Assert.That(op.Disabled, Is.False);
Assert.That(renameColumn1Op.Disabled, Is.True);
Assert.That(renameColumn2Op.Disabled, Is.True);
Assert.That(renameTableOp.Disabled, Is.True);
Assert.That(columns[0].Name, Is.EqualTo("C1New"));
Assert.That(columns[1].Name, Is.EqualTo("C2New"));
Assert.That(renameColumn2Op.TableName, Is.EqualTo("T1New"));
Assert.That(renameColumn1Op.TableName, Is.EqualTo("T1New"));
Assert.That(op.Name, Is.EqualTo("T1New"));
}
protected override void Generate(RenameColumnOperation renameColumnOperation)
{
string newTableName = getNameWithReplacedSchema(renameColumnOperation.Table);
var newRenameColumnOperation = new RenameColumnOperation(newTableName, renameColumnOperation.Name, renameColumnOperation.NewName);
base.Generate(newRenameColumnOperation);
}
public void Create_and_initialize_operation()
{
var renameColumnOperation = new RenameColumnOperation("dbo.MyTable", "Foo", "Foo2");
Assert.Equal("dbo.MyTable", renameColumnOperation.TableName);
Assert.Equal("Foo", renameColumnOperation.ColumnName);
Assert.Equal("Foo2", renameColumnOperation.NewColumnName);
Assert.False(renameColumnOperation.IsDestructiveChange);
}
public void ShouldSetPropertiesForRenameColumnOperation()
{
var op = new RenameColumnOperation(SchemaName, TableName, CurrentName, NewName);
Assert.AreEqual(SchemaName, op.SchemaName);
Assert.AreEqual(TableName, op.TableName);
Assert.AreEqual(CurrentName, op.Name);
Assert.AreEqual(NewName, op.NewName);
}
protected override void Generate(
RenameColumnOperation operation,
IModel?model,
MigrationCommandListBuilder builder)
{
base.Generate(operation, model, builder);
ReplaceWriteToEventLogFunctionIfEventLogTableTouched(model, builder, targetTableName: operation.Table);
}
public void ShouldNotUpateColumnNameIfNotSameSchemaTableOrColumn(string schemaName, string tableName, string columnName)
{
var op = new AddRowGuidColOperation("schema", "table", "column");
var renameOp = new RenameColumnOperation(schemaName, tableName, columnName, "new column");
op.Merge(renameOp);
Assert.That(op.Disabled, Is.False);
Assert.That(renameOp.Disabled, Is.False);
Assert.That(op.ColumnName, Is.EqualTo("column"));
}
public void Dispatches_visitor()
{
var renameColumnOperation = new RenameColumnOperation("dbo.MyTable", "Foo", "Foo2");
var mockVisitor = new Mock <MigrationOperationSqlGenerator>(new RelationalTypeMapper());
var builder = new Mock <IndentedStringBuilder>();
renameColumnOperation.GenerateSql(mockVisitor.Object, builder.Object);
mockVisitor.Verify(g => g.Generate(renameColumnOperation, builder.Object), Times.Once());
}
public override void Visit(RenameColumnOperation renameColumnOperation, DatabaseModel databaseModel)
{
Check.NotNull(renameColumnOperation, "renameColumnOperation");
Check.NotNull(databaseModel, "databaseModel");
var table = databaseModel.GetTable(renameColumnOperation.TableName);
var column = table.GetColumn(renameColumnOperation.ColumnName);
column.Name = renameColumnOperation.NewColumnName;
}
public void Dispatches_visitor()
{
var renameColumnOperation = new RenameColumnOperation("dbo.MyTable", "Foo", "Foo2");
var mockVisitor = MigrationsTestHelpers.MockSqlGenerator();
var builder = new Mock <SqlBatchBuilder>();
renameColumnOperation.GenerateSql(mockVisitor.Object, builder.Object);
mockVisitor.Verify(g => g.Generate(renameColumnOperation, builder.Object), Times.Once());
}
public override void Visit(RenameColumnOperation operation, Context context)
{
Check.NotNull(operation, "operation");
Check.NotNull(context, "context");
var handler = context.EnsureHandler(operation.TableName, supported: false);
handler.AddOperation(operation);
handler.ResetColumnNamePair(operation.ColumnName, operation.NewColumnName);
}
public void ShouldRemoveIfTableColumnIsRemoved()
{
var op = new AddExtendedPropertyOperation("schema", "table", "column", "name", "value", false);
var renameOp = new RenameColumnOperation("SCHEMA", "TABLE", "COLUMN", "newcolumn");
op.Merge(renameOp);
Assert.That(op.Disabled, Is.False);
Assert.That(renameOp.Disabled, Is.False);
Assert.That(op.ColumnName, Is.EqualTo("newcolumn"));
}
public void ShouldUpateColumnNameIfItIsRenamed()
{
var op = new AddRowGuidColOperation("schema", "table", "column");
var renameOp = new RenameColumnOperation("SCHEMA", "TABLE", "COLUMN", "new column");
op.Merge(renameOp);
Assert.That(op.Disabled, Is.False);
Assert.That(renameOp.Disabled, Is.True);
Assert.That(op.ColumnName, Is.EqualTo("new column"));
}
protected override void Generate(RenameColumnOperation operation, IModel model, MigrationCommandListBuilder builder)
{
builder.Append("ALTER TABLE ");
builder.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Table, operation.Schema));
builder.Append(" ALTER COLUMN ");
builder.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Name));
builder.Append(" TO ");
builder.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.NewName));
TerminateStatement(builder);
}
public void Generate_when_rename_column_operation()
{
var operation = new RenameColumnOperation("dbo.MyTable", "Foo", "Foo2");
Assert.Equal(
@"RenameColumn(""dbo.MyTable"", ""Foo"", ""Foo2"")",
CSharpMigrationCodeGenerator.Generate(operation));
GenerateAndValidateCode(operation);
}
public void Generate_should_throw_when_column_rename()
{
var migrationProvider = new SqlCeMigrationSqlGenerator();
var renameColumnOperation = new RenameColumnOperation("T", "c", "c'");
Assert.Equal(
Strings.SqlCeColumnRenameNotSupported,
Assert.Throws <MigrationsException>(() => migrationProvider.Generate(new[] { renameColumnOperation }, "4.0").ToList()).
Message);
}
protected override void Generate(
RenameColumnOperation operation,
IModel model,
MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
builder.Append($"RENAME COLUMN [{operation.Table}].[{TruncateName(operation.Name)}] TO [{TruncateName(operation.NewName)}]");
builder.EndCommand();
}
public static OperationBuilderSurface <RenameColumnOperation> RenameColumn(this IMigrationBuilder builder, string oldName, string newName, string table, string schema = null, string catalog = null)
{
var op = new RenameColumnOperation
{
OldName = new SubObjectName(catalog, schema, table, oldName),
NewName = new SubObjectName(catalog, schema, table, newName)
};
builder.AddOperation(op);
return(new OperationBuilderSurface <RenameColumnOperation>(op));
}
private void RegisterTableForRebuild(string tableName, RenameColumnOperation operation = null)
{
if (!_tableRebuilds.ContainsKey(tableName))
{
_tableRebuilds.Add(tableName, new List <RenameColumnOperation>());
}
if (operation != null)
{
_tableRebuilds[tableName].Add(operation);
}
}
protected override void Generate(RenameColumnOperation operation, IModel model, SqlBatchBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
GenerateRename(
_sql.EscapeLiteral(operation.Table) + "." + _sql.EscapeLiteral(operation.Name),
operation.Schema,
operation.NewName,
"COLUMN",
builder);
}
private static string RenameColumnOperationToSql(RenameColumnOperation renameColumnOperation, DbContext _dbContext)
{
string column_type = string.Empty;
string sql = "select column_type from information_schema.columns where table_name='" + (renameColumnOperation as RenameColumnOperation).Table + "' and column_name='" + (renameColumnOperation as RenameColumnOperation).Name + "'";
var dataTable = _dbContext.SqlQuery(sql);
if (dataTable != null && dataTable.Rows.Count > 0)
{
column_type = dataTable.Rows[0].ItemArray[0].ToString();
}
return("alter table " + (renameColumnOperation as RenameColumnOperation).Table + " change column " + (renameColumnOperation as RenameColumnOperation).Name + " " + (renameColumnOperation as RenameColumnOperation).NewName + " " + column_type + " ;");
}
protected virtual IEnumerable <MigrationStatement> Generate(RenameColumnOperation operation)
{
using (var writer = SqlWriter())
{
writer.Write("ALTER TABLE ");
writer.Write(Quote(CheckName(ExtractName(operation.Table))));
writer.Write(" ALTER COLUMN ");
writer.Write(Quote(CheckName(operation.Name)));
writer.Write(" TO ");
writer.Write(Quote(CheckName(operation.NewName)));
yield return(Statement(writer));
}
}
public override void Generate(RenameColumnOperation renameColumnOperation, IndentedStringBuilder stringBuilder)
{
Check.NotNull(renameColumnOperation, "renameColumnOperation");
stringBuilder
.Append("EXECUTE sp_rename @objname = N'")
.Append(EscapeLiteral(renameColumnOperation.TableName))
.Append(".")
.Append(EscapeLiteral(renameColumnOperation.ColumnName))
.Append("', @newname = N")
.Append(DelimitLiteral(renameColumnOperation.NewColumnName))
.Append(", @objtype = N'COLUMN'");
}
