private static IEnumerable <PrimaryKeyOperation> BuildChangePrimaryKeyOperations(
string oldTable, string newTable, XElement oldKey, XElement newKey)
{
var dropPrimaryKeyOperation
= new DropPrimaryKeyOperation
{
Table = oldTable,
IsSystem = oldKey.IsSystem()
};
oldKey.Descendants(EdmXNames.Ssdl.PropertyRefNames).Each(
pr => dropPrimaryKeyOperation.Columns.Add(pr.NameAttribute()));
yield return(dropPrimaryKeyOperation);
var addPrimaryKeyOperation
= new AddPrimaryKeyOperation
{
Table = newTable,
IsSystem = newKey.IsSystem()
};
newKey.Descendants(EdmXNames.Ssdl.PropertyRefNames).Each(
pr => addPrimaryKeyOperation.Columns.Add(pr.NameAttribute()));
yield return(addPrimaryKeyOperation);
}
protected virtual void Generate([NotNull] DropPrimaryKeyOperation operation, [NotNull] IndentedStringBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
builder
.Append(".DropPrimaryKey(name: ")
.Append(_code.Literal(operation.Name));
if (operation.Schema != null)
{
builder
.Append(", schema: ")
.Append(_code.Literal(operation.Schema));
}
builder
.Append(", table: ")
.Append(_code.Literal(operation.Table))
.Append(")");
using (builder.Indent())
{
Annotations(operation.Annotations, builder);
}
}
/// <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 "
});
}
public override void Generate(
DropPrimaryKeyOperation dropPrimaryKeyOperation,
IndentedStringBuilder stringBuilder)
{
// TODO: Rebuild table
throw new NotImplementedException();
}
private HistoryRebuildOperationSequence(
AddColumnOperation addColumnOperation,
DropPrimaryKeyOperation dropPrimaryKeyOperation)
: base(null)
{
AddColumnOperation = addColumnOperation;
DropPrimaryKeyOperation = dropPrimaryKeyOperation;
}
public void Create_and_initialize_operation()
{
var dropPrimaryKeyOperation = new DropPrimaryKeyOperation("dbo.MyTable", "MyPK");
Assert.Equal("dbo.MyTable", dropPrimaryKeyOperation.TableName);
Assert.Equal("MyPK", dropPrimaryKeyOperation.PrimaryKeyName);
Assert.True(dropPrimaryKeyOperation.IsDestructiveChange);
}
protected override void Generate([NotNull] DropPrimaryKeyOperation operation, [CanBeNull] IModel model, [NotNull] MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
//future implementation
EndStatement(builder);
}
protected override void Generate(DropPrimaryKeyOperation operation, IModel model, MigrationCommandListBuilder builder)
{
builder.Append("ALTER TABLE ")
.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Table, operation.Schema))
.Append(" DROP CONSTRAINT ")
.Append(operation.Name);
EndStatement(builder);
}
protected virtual IEnumerable <MigrationStatement> Generate(DropPrimaryKeyOperation operation)
{
using (var writer = SqlWriter())
{
writer.Write("DROP INDEX ");
writer.Write(Quote(string.Format("{0}.{1}", SchemaName(operation.Table), FixName(operation.Name))));
yield return(Statement(writer));
}
}
public void DropPrimaryKeyOperation()
{
var migrationOperations = new List <MigrationOperation>();
// create table where the PK exists
var createTableOperation = CreateTableOperation();
migrationOperations.Add(createTableOperation);
var createDropPKOperation = new DropPrimaryKeyOperation(anonymousArguments: new { DeleteAutoIncrement = true });
createDropPKOperation.Table = "Posts";
createDropPKOperation.Columns.Add("PostId");
migrationOperations.Add(createDropPKOperation);
using (BlogContext context = new BlogContext())
{
if (context.Database.Exists())
{
context.Database.Delete();
}
context.Database.Create();
Assert.Equal(true, GenerateAndExecuteMySQLStatements(migrationOperations));
using (var conn = new MySqlConnection(context.Database.Connection.ConnectionString))
{
if (conn.State == System.Data.ConnectionState.Closed)
{
conn.Open();
}
// check for table creation
var query = new MySqlCommand("select Count(*) from information_schema.Tables WHERE `table_name` = 'Posts' and `table_schema` = '" + conn.Database + "' ", conn);
int rows = Convert.ToInt32(query.ExecuteScalar());
Assert.Equal(1, rows);
// check if PK exists
query = new MySqlCommand("select Count(*) from information_schema.table_constraints where `constraint_type` = 'primary key' and `constraint_schema` = '" + conn.Database + "' and table_name= 'Posts'", conn);
rows = Convert.ToInt32(query.ExecuteScalar());
Assert.Equal(0, rows);
//check the definition of the column that was PK
query = new MySqlCommand("Select Column_name, Is_Nullable, Data_Type from information_schema.Columns where table_schema ='" + conn.Database + "' and table_name = 'Posts' and column_name ='PostId'", conn);
MySqlDataReader reader = query.ExecuteReader();
while (reader.Read())
{
Assert.Equal("PostId", reader[0].ToString());
Assert.Equal("NO", reader[1].ToString());
Assert.Equal("int", reader[2].ToString());
}
reader.Close();
conn.Close();
}
}
}
protected override void Generate([NotNull] DropPrimaryKeyOperation operation, [CanBeNull] IModel model, [NotNull] MigrationCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
builder.Append(@"DROP PROCEDURE IF EXISTS POMELO_BEFORE_DROP_PRIMARY_KEY;
CREATE PROCEDURE POMELO_BEFORE_DROP_PRIMARY_KEY(IN `TABLE_NAME_ARGUMENT` VARCHAR(255))
BEGIN
DECLARE HAS_AUTO_INCREMENT_ID TINYINT(1);
DECLARE PRIMARY_KEY_COLUMN_NAME VARCHAR(255);
DECLARE PRIMARY_KEY_TYPE VARCHAR(255);
DECLARE SQL_EXP VARCHAR(1000);
SELECT COUNT(*)
INTO HAS_AUTO_INCREMENT_ID
FROM `information_schema`.`COLUMNS`
WHERE `TABLE_SCHEMA` = (SELECT SCHEMA())
AND `TABLE_NAME` = TABLE_NAME_ARGUMENT
AND `Extra` = 'auto_increment'
AND `COLUMN_KEY` = 'PRI'
LIMIT 1;
IF HAS_AUTO_INCREMENT_ID THEN
SELECT `COLUMN_TYPE`
INTO PRIMARY_KEY_TYPE
FROM `information_schema`.`COLUMNS`
WHERE `TABLE_SCHEMA` = (SELECT SCHEMA())
AND `TABLE_NAME` = TABLE_NAME_ARGUMENT
AND `COLUMN_KEY` = 'PRI'
LIMIT 1;
SELECT `COLUMN_NAME`
INTO PRIMARY_KEY_COLUMN_NAME
FROM `information_schema`.`COLUMNS`
WHERE `TABLE_SCHEMA` = (SELECT SCHEMA())
AND `TABLE_NAME` = TABLE_NAME_ARGUMENT
AND `COLUMN_KEY` = 'PRI'
LIMIT 1;
SET SQL_EXP = CONCAT('ALTER TABLE `', (SELECT SCHEMA()), '`.`', TABLE_NAME_ARGUMENT, '` MODIFY COLUMN `', PRIMARY_KEY_COLUMN_NAME, '` ', PRIMARY_KEY_TYPE, ' NOT NULL;');
SET @SQL_EXP = SQL_EXP;
PREPARE SQL_EXP_EXECUTE FROM @SQL_EXP;
EXECUTE SQL_EXP_EXECUTE;
DEALLOCATE PREPARE SQL_EXP_EXECUTE;
END IF;
END;");
builder.AppendLine();
builder.Append($"CALL POMELO_BEFORE_DROP_PRIMARY_KEY('{ operation.Table }');");
builder.AppendLine();
builder.Append($"DROP PROCEDURE IF EXISTS POMELO_BEFORE_DROP_PRIMARY_KEY;");
builder.AppendLine();
builder
.Append("ALTER TABLE ")
.Append(SqlGenerationHelper.DelimitIdentifier(operation.Table, operation.Schema))
.Append(" DROP PRIMARY KEY;")
.AppendLine();
EndStatement(builder);
}
private string GenerateSqlStatementConcrete(DropPrimaryKeyOperation migrationOperation)
{
DB2DdlBuilder ddlBuilder = new DB2DdlBuilder();
ddlBuilder.AppendSql("ALTER TABLE ");
ddlBuilder.AppendIdentifier(migrationOperation.Table);
ddlBuilder.AppendSql(" DROP PRIMARY KEY ");
return(ddlBuilder.GetCommandText());
}
public override void Visit(DropPrimaryKeyOperation operation, Context context)
{
Check.NotNull(operation, "operation");
Check.NotNull(context, "context");
var handler = context.EnsureHandler(operation.TableName, supported: false);
handler.AddOperation(operation);
}
protected override void Generate(
DropPrimaryKeyOperation operation,
IModel model,
MigrationCommandListBuilder builder,
bool terminate = true)
{
// It does nothing due to this operation should not be isolated for MySQL
EndStatement(builder);
}
public void Dispatches_visitor()
{
var dropPrimaryKeyOperation = new DropPrimaryKeyOperation("dbo.MyTable", "MyPK");
var mockVisitor = new Mock <MigrationOperationSqlGenerator>(new RelationalTypeMapper());
var builder = new Mock <IndentedStringBuilder>();
dropPrimaryKeyOperation.GenerateSql(mockVisitor.Object, builder.Object);
mockVisitor.Verify(g => g.Generate(dropPrimaryKeyOperation, builder.Object), Times.Once());
}
public void Dispatches_visitor()
{
var dropPrimaryKeyOperation = new DropPrimaryKeyOperation("dbo.MyTable", "MyPK");
var mockVisitor = MigrationsTestHelpers.MockSqlGenerator();
var builder = new Mock <SqlBatchBuilder>();
dropPrimaryKeyOperation.GenerateSql(mockVisitor.Object, builder.Object);
mockVisitor.Verify(g => g.Generate(dropPrimaryKeyOperation, builder.Object), Times.Once());
}
protected override void Generate(
DropPrimaryKeyOperation operation,
IModel model,
MigrationCommandListBuilder builder)
{
ThrowIf.Argument.IsNull(operation, "operation");
ThrowIf.Argument.IsNull(builder, "builder");
throw new NotImplementedException();
}
public virtual void Visit(DropPrimaryKeyOperation dropPrimaryKeyOperation, DatabaseModel databaseModel)
{
var table = databaseModel.GetTable(dropPrimaryKeyOperation.TableName);
Contract.Assert(
table.PrimaryKey != null &&
table.PrimaryKey.Name == dropPrimaryKeyOperation.PrimaryKeyName);
table.PrimaryKey = null;
}
public virtual void Generate([NotNull] DropPrimaryKeyOperation dropPrimaryKeyOperation, [NotNull] IndentedStringBuilder stringBuilder, bool generateIdempotentSql)
{
Check.NotNull(dropPrimaryKeyOperation, "dropPrimaryKeyOperation");
stringBuilder
.Append("ALTER TABLE ")
.Append(DelimitIdentifier(dropPrimaryKeyOperation.TableName))
.Append(" DROP CONSTRAINT ")
.Append(DelimitIdentifier(dropPrimaryKeyOperation.PrimaryKeyName));
}
public void Generate_when_drop_primary_key_operation()
{
var operation = new DropPrimaryKeyOperation("dbo.MyTable", "MyPK");
Assert.Equal(
@"DropPrimaryKey(""dbo.MyTable"", ""MyPK"")",
CSharpMigrationCodeGenerator.Generate(operation));
GenerateAndValidateCode(operation);
}
private string GenerateSqlStatementConcrete(DropPrimaryKeyOperation migrationOperation)
{
var ddlBuilder = new SQLiteDdlBuilder();
ddlBuilder.AppendSql("ALTER TABLE ");
ddlBuilder.AppendIdentifier(migrationOperation.Table);
ddlBuilder.AppendSql(" DROP CONSTRAINT ");
ddlBuilder.AppendIdentifier(migrationOperation.Name);
return(ddlBuilder.GetCommandText());
}
protected override void Generate(
DropPrimaryKeyOperation operation,
IModel model,
MigrationCommandListBuilder builder)
{
base.Generate(operation, model, builder, terminate: false);
builder
.AppendLine(Dependencies.SqlGenerationHelper.StatementTerminator)
.EndCommand();
}
protected internal void DropPrimaryKey(string table, string schema = "dbo", object anonymousArguments = null)
{
RuntimeFailureMethods.Requires(!string.IsNullOrWhiteSpace(table), null, "!string.IsNullOrWhiteSpace(table)");
table = string.Format("{0}.{1}", schema, table);
var migrationOperation = new DropPrimaryKeyOperation(anonymousArguments)
{
Table = table
};
AddOperation(migrationOperation);
}
protected virtual IEnumerable <MigrationStatement> Generate(DropPrimaryKeyOperation operation)
{
using (var writer = SqlWriter())
{
writer.Write("ALTER TABLE ");
writer.Write(Quote(CheckName(ExtractName(operation.Table))));
writer.Write(" DROP CONSTRAINT ");
writer.Write(Quote(CheckName(CreateItemName(operation.Name))));
yield return(Statement(writer));
}
}
private void Convert(DropPrimaryKeyOperation dropPrimaryKeyOperation)
{
StringBuilder sql = new StringBuilder();
sql.Append("ALTER TABLE ");
AppendTableName(dropPrimaryKeyOperation.Table, sql);
sql.Append(" DROP CONSTRAINT \"");
sql.Append(dropPrimaryKeyOperation.Name);
sql.Append('"');
AddStatment(sql);
}
protected override void Generate(
DropPrimaryKeyOperation operation,
IModel model,
MigrationCommandListBuilder builder)
{
base.Generate(operation, model, builder, terminate: false);
builder
.AppendLine(Dependencies.SqlGenerationHelper.StatementTerminator)
.EndCommand(suppressTransaction: IsMemoryOptimized(operation, model, operation.Schema, operation.Table));
}
public virtual void Generate([NotNull] DropPrimaryKeyOperation dropPrimaryKeyOperation, [NotNull] SqlBatchBuilder batchBuilder)
{
Check.NotNull(dropPrimaryKeyOperation, "dropPrimaryKeyOperation");
Check.NotNull(batchBuilder, "batchBuilder");
batchBuilder
.Append("ALTER TABLE ")
.Append(DelimitIdentifier(dropPrimaryKeyOperation.TableName))
.Append(" DROP CONSTRAINT ")
.Append(DelimitIdentifier(dropPrimaryKeyOperation.PrimaryKeyName));
}
protected virtual void Generate(DropPrimaryKeyOperation opeDropPrimaryKey)
{
using (var ltextWriter = TextWriter())
{
ltextWriter.Write("ALTER TABLE ");
ltextWriter.Write(RemoveDBO(opeDropPrimaryKey.Table));
ltextWriter.Write(" DROP CONSTRAINT ");
ltextWriter.Write(opeDropPrimaryKey.Name);
ComandoSQL(ltextWriter);
}
}
public override void Generate([NotNull] DropPrimaryKeyOperation dropPrimaryKeyOperation, [NotNull] IndentedStringBuilder stringBuilder)
{
Check.NotNull(dropPrimaryKeyOperation, "dropPrimaryKeyOperation");
Check.NotNull(stringBuilder, "stringBuilder");
stringBuilder
.Append("DropPrimaryKey(")
.Append(GenerateLiteral(dropPrimaryKeyOperation.TableName))
.Append(", ")
.Append(GenerateLiteral(dropPrimaryKeyOperation.PrimaryKeyName))
.Append(")");
}
public async Task DropPrimaryKey()
{
var operation = new DropPrimaryKeyOperation()
{
Table = "People",
Name = "PK_People",
};
var batch = await Generate(new[] { operation });
Assert.AreEqual(1, batch.Count());
Assert.AreEqual(NewLineEnd(@"ALTER TABLE ""People"" DROP CONSTRAINT ""PK_People"";"), batch[0].CommandText);
}
