public virtual void Generate([NotNull] DropColumnOperation dropColumnOperation, [NotNull] IndentedStringBuilder stringBuilder)
{
Check.NotNull(dropColumnOperation, "dropColumnOperation");
stringBuilder
.Append("ALTER TABLE ")
.Append(DelimitIdentifier(dropColumnOperation.TableName))
.Append(" DROP COLUMN ")
.Append(DelimitIdentifier(dropColumnOperation.ColumnName));
}
public void Dispatches_visitor()
{
var dropColumnOperation = new DropColumnOperation("dbo.MyTable", "Foo");
var mockVisitor = MigrationsTestHelpers.MockSqlGenerator();
var builder = new Mock <SqlBatchBuilder>();
dropColumnOperation.GenerateSql(mockVisitor.Object, builder.Object);
mockVisitor.Verify(g => g.Generate(dropColumnOperation, builder.Object), Times.Once());
}
public static OperationBuilderSurface <DropColumnOperation> DropColumn(this IMigrationBuilder builder, string name, string table, string schema = null, string catalog = null)
{
var op = new DropColumnOperation
{
Name = new SubObjectName(catalog, schema, table, name)
};
builder.AddOperation(op);
return(new OperationBuilderSurface <DropColumnOperation>(op));
}
private string GenerateSqlStatementConcrete(DropColumnOperation migrationOperation)
{
JetDdlBuilder ddlBuilder = new JetDdlBuilder();
ddlBuilder.AppendSql("ALTER TABLE ");
ddlBuilder.AppendIdentifier(migrationOperation.Table);
ddlBuilder.AppendSql(" DROP COLUMN ");
ddlBuilder.AppendIdentifier(migrationOperation.Name);
return(ddlBuilder.GetCommandText());
}
public virtual void Generate([NotNull] DropColumnOperation dropColumnOperation, [NotNull] SqlBatchBuilder batchBuilder)
{
Check.NotNull(dropColumnOperation, "dropColumnOperation");
Check.NotNull(batchBuilder, "batchBuilder");
batchBuilder
.Append("ALTER TABLE ")
.Append(DelimitIdentifier(dropColumnOperation.TableName))
.Append(" DROP COLUMN ")
.Append(DelimitIdentifier(dropColumnOperation.ColumnName));
}
protected override void Generate(
DropColumnOperation operation,
IModel model,
RelationalCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
DropDefaultConstraint(operation.Schema, operation.Table, operation.Name, builder);
base.Generate(operation, model, builder);
}
/// <summary>
/// Generates code to perform a <see cref="DropColumnOperation" />.
/// </summary>
/// <param name="dropColumnOperation"> The operation to generate code for. </param>
/// <param name="writer"> Text writer to add the generated code to. </param>
protected virtual void Generate(DropColumnOperation dropColumnOperation, IndentedTextWriter writer)
{
Check.NotNull(dropColumnOperation, "dropColumnOperation");
Check.NotNull(writer, "writer");
writer.Write("DropColumn(");
writer.Write(Quote(dropColumnOperation.Table));
writer.Write(", ");
writer.Write(Quote(dropColumnOperation.Name));
writer.WriteLine(")");
}
protected override void Generate(DropColumnOperation operation, IModel model, MigrationCommandListBuilder builder, bool terminate = true)
{
builder.Append("ALTER TABLE ");
builder.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Table, operation.Schema));
builder.Append(" DROP ");
builder.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Name));
if (terminate)
{
TerminateStatement(builder);
}
}
private void Convert(DropColumnOperation dropColumnOperation)
{
StringBuilder sql = new StringBuilder();
sql.Append("ALTER TABLE ");
AppendTableName(dropColumnOperation.Table, sql);
sql.Append(" DROP COLUMN \"");
sql.Append(dropColumnOperation.Name);
sql.Append('"');
AddStatment(sql);
}
protected virtual IEnumerable <MigrationStatement> Generate(DropColumnOperation operation)
{
using (var writer = SqlWriter())
{
writer.Write("ALTER TABLE ");
writer.Write(Quote(CheckName(ExtractName(operation.Table))));
writer.Write(" DROP ");
writer.Write(Quote(CheckName(operation.Name)));
yield return(Statement(writer));
}
}
protected override void Generate(DropColumnOperation operation, IModel model, MigrationCommandListBuilder builder)
{
var identifier = Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Table, operation.Schema);
var alterBase = $"ALTER TABLE {identifier} DROP {Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Name)}";
builder
.Append(alterBase)
.Append(Dependencies.SqlGenerationHelper.StatementTerminator);
EndStatement(builder);
}
protected override void Generate(
[NotNull] DropColumnOperation operation,
[CanBeNull] IModel model,
[NotNull] SqlBatchBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
DropDefaultConstraint(operation.Schema, operation.Table, operation.Name, builder);
base.Generate(operation, model, builder);
}
/// <inheritdoc />
protected override void Generate(DropColumnOperation dropColumnOperation)
{
using (var writer = Writer())
{
writer.Write("ALTER TABLE ");
writer.Write(Name(dropColumnOperation.Table));
writer.Write(" DROP COLUMN ");
writer.Write(Quote(dropColumnOperation.Name));
Statement(writer);
}
}
public async Task DropColumn()
{
var operation = new DropColumnOperation()
{
Table = "People",
Name = "DropMe",
};
var batch = await Generate(new[] { operation });
Assert.AreEqual(1, batch.Count());
Assert.AreEqual(NewLineEnd(@"ALTER TABLE ""People"" DROP ""DropMe"";"), batch[0].CommandText);
}
protected virtual void Generate(DropColumnOperation opeRemoveColuna)
{
using (var ltextWriter = TextWriter())
{
ltextWriter.Write("ALTER TABLE ");
ltextWriter.Write(RemoveDBO(opeRemoveColuna.Table));
ltextWriter.Write(" DROP COLUMN ");
ltextWriter.Write(opeRemoveColuna.Name);
ComandoSQL(ltextWriter);
}
}
public override void Generate([NotNull] DropColumnOperation dropColumnOperation, [NotNull] IndentedStringBuilder stringBuilder)
{
Check.NotNull(dropColumnOperation, "dropColumnOperation");
Check.NotNull(stringBuilder, "stringBuilder");
stringBuilder
.Append("DropColumn(")
.Append(GenerateLiteral(dropColumnOperation.TableName))
.Append(", ")
.Append(GenerateLiteral(dropColumnOperation.ColumnName))
.Append(")");
}
/// <summary>
/// Generates a migration operation to drop a column.
/// </summary>
/// <param name="op">The operation that represents a column being dropped from a table.</param>
/// <returns>The migration operation to drop a column.</returns>
protected virtual MigrationStatement Generate(DropColumnOperation op)
{
if (op == null)
{
return(null);
}
MigrationStatement stmt = new MigrationStatement();
stmt.Sql = EndsWithSemicolon(string.Format("alter table `{0}` drop column `{1}`",
TrimSchemaPrefix(op.Table), op.Name));
return(stmt);
}
/// <summary>
/// 删除列。
/// </summary>
/// <typeparam name="TEntity">实体类型。</typeparam>
/// <param name="name">列名称。</param>
/// <returns>返回迁移实例。</returns>
public virtual OperationBuilder <DropColumnOperation> DropColumn <TEntity>(string name)
{
Check.NotEmpty(name, nameof(name));
var operation = new DropColumnOperation
{
Table = typeof(TEntity).GetTableName(),
Name = name
};
Operations.Add(operation);
return(new OperationBuilder <DropColumnOperation>(operation));
}
private void Generate(DropColumnOperation dropColumnOperation)
{
Contract.Requires(dropColumnOperation != null);
using (var writer = Writer())
{
writer.Write("ALTER TABLE ");
writer.Write(Name(dropColumnOperation.Table));
writer.Write(" DROP COLUMN ");
writer.Write(Name(dropColumnOperation.Name));
Statement(writer);
}
}
protected override void Generate(
DropColumnOperation operation,
IModel model,
MigrationCommandListBuilder builder,
bool terminate)
{
// Never touch system columns
if (IsSystemColumn(operation.Name))
{
return;
}
base.Generate(operation, model, builder, terminate);
}
protected virtual MigrationStatement Generate(DropColumnOperation op)
{
if (op == null)
{
return(null);
}
MigrationStatement stmt = new MigrationStatement();
StringBuilder sb = new StringBuilder();
stmt.Sql = string.Format("alter table `{0}` drop column `{1}`",
op.Table, op.Name);
return(stmt);
}
public virtual void Generate(
[NotNull] DropColumnOperation operation,
[CanBeNull] IModel model,
[NotNull] SqlBatchBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
builder
.Append("ALTER TABLE ")
.Append(_sql.DelimitIdentifier(operation.Table, operation.Schema))
.Append(" DROP COLUMN ")
.Append(_sql.DelimitIdentifier(operation.Name));
}
/// <summary>
/// Generates SQL for a <see cref="DropColumnOperation" />.
/// Generated SQL should be added using the Statement method.
/// </summary>
/// <param name="dropColumnOperation"> The operation to produce SQL for. </param>
protected virtual void Generate(DropColumnOperation dropColumnOperation)
{
Check.NotNull(dropColumnOperation, "dropColumnOperation");
using (var writer = Writer())
{
writer.Write("ALTER TABLE ");
writer.Write(Name(dropColumnOperation.Table));
writer.Write(" DROP COLUMN ");
writer.Write(Quote(dropColumnOperation.Name));
Statement(writer);
}
}
public void Visit_with_drop_column_operation()
{
var model = new DatabaseModel();
var table = new Table("dbo.MyTable", new[] { new Column("Foo", typeof(int)) });
var operation = new DropColumnOperation("dbo.MyTable", "Foo");
model.AddTable(table);
Assert.Equal(1, table.Columns.Count);
operation.Accept(new DatabaseModelModifier(), model);
Assert.Equal(0, table.Columns.Count);
}
protected virtual void Generate(
[NotNull] DropColumnOperation operation,
[CanBeNull] IModel model,
[NotNull] RelationalCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
builder
.Append("ALTER TABLE ")
.Append(SqlGenerator.DelimitIdentifier(operation.Table, operation.Schema))
.Append(" DROP COLUMN ")
.Append(SqlGenerator.DelimitIdentifier(operation.Name));
}
protected virtual void Process(DropColumnOperation dropColumnOperation, Context context)
{
Check.NotNull(dropColumnOperation, "dropColumnOperation");
Check.NotNull(context, "context");
var entityType = context.SourceModel.EntityTypes.Single(
t => NameBuilder.SchemaQualifiedTableName(t) == dropColumnOperation.TableName);
var property = entityType.Properties.Single(
p => NameBuilder.ColumnName(p) == dropColumnOperation.ColumnName);
var extensions = property.SqlServer();
if (extensions.DefaultValue != null || extensions.DefaultExpression != null)
{
context.Operations.Add(OperationFactory.DropDefaultConstraintOperation(property));
}
}
public virtual OperationBuilder <DropColumnOperation> DropColumn(string name, string table, string schema = null)
{
Check.NotEmpty(name, nameof(name));
Check.NotEmpty(table, nameof(table));
var operation = new DropColumnOperation
{
Schema = schema,
Table = table,
Name = name
};
Operations.Add(operation);
return(new OperationBuilder <DropColumnOperation>(operation));
}
private void Generate(DropColumnOperation dropColumnOperation)
{
ArgumentUtility.CheckNotNull("dropColumnOperation", dropColumnOperation);
throw new NotImplementedException("DropColumnOperation");
//using (var writer = Writer()) {
// DropDefaultConstraint(dropColumnOperation.Table, dropColumnOperation.Name, writer);
// writer.Write("ALTER TABLE ");
// writer.Write(Name(dropColumnOperation.Table));
// writer.Write(" DROP COLUMN ");
// writer.Write(Quote(dropColumnOperation.Name));
// Statement(writer);
//}
}
/// <summary>
/// 删除列。
/// </summary>
/// <param name="operation">操作实例。</param>
/// <param name="builder"><see cref="MigrationCommandListBuilder"/>实例对象。</param>
/// <param name="terminate">是否结束语句。</param>
protected override void Generate(
DropColumnOperation operation,
MigrationCommandListBuilder builder,
bool terminate)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
DropDefaultConstraint(operation.Table, operation.Name, builder);
base.Generate(operation, builder, false);
if (terminate)
{
builder
.AppendLine(SqlHelper.StatementTerminator)
.EndCommand();
}
}
protected override void Generate(
DropColumnOperation operation,
IModel model,
MigrationCommandListBuilder builder,
bool terminate)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
DropDefaultConstraint(operation.Schema, operation.Table, operation.Name, builder);
base.Generate(operation, model, builder, terminate: false);
if (terminate)
{
builder
.AppendLine(Dependencies.SqlGenerationHelper.StatementTerminator)
.EndCommand(suppressTransaction: IsMemoryOptimized(operation, model, operation.Schema, operation.Table));
}
}
