protected virtual void Generate(
[NotNull] AddForeignKeyOperation operation,
[CanBeNull] IModel model,
[NotNull] MigrationCommandListBuilder builder,
bool terminate)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
builder
.Append("ALTER TABLE ")
.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Table, operation.Schema))
.Append(" ADD ");
ForeignKeyConstraint(operation, model, builder);
if (terminate)
{
builder.AppendLine(Dependencies.SqlGenerationHelper.StatementTerminator);
EndStatement(builder);
}
}
protected virtual IEnumerable <MigrationStatement> Generate(AddForeignKeyOperation operation)
{
using (var writer = SqlWriter())
{
writer.Write("ALTER TABLE ");
writer.Write(Quote(CheckName(ExtractName(operation.DependentTable))));
writer.Write(" ADD CONSTRAINT ");
writer.Write(Quote(CheckName(CreateItemName(operation.Name))));
writer.Write(" FOREIGN KEY (");
WriteColumns(writer, operation.DependentColumns.Select(Quote));
writer.Write(") REFERENCES ");
writer.Write(Quote(CheckName(ExtractName(operation.PrincipalTable))));
writer.Write(" (");
WriteColumns(writer, operation.PrincipalColumns.Select(Quote));
writer.Write(")");
if (operation.CascadeDelete)
{
writer.Write(" ON DELETE CASCADE");
}
yield return(Statement(writer));
}
}
public virtual void Generate([NotNull] AddForeignKeyOperation addForeignKeyOperation, [NotNull] IndentedStringBuilder stringBuilder, bool generateIdempotentSql)
{
Check.NotNull(addForeignKeyOperation, "addForeignKeyOperation");
stringBuilder
.Append("ALTER TABLE ")
.Append(DelimitIdentifier(addForeignKeyOperation.TableName))
.Append(" ADD CONSTRAINT ")
.Append(DelimitIdentifier(addForeignKeyOperation.ForeignKeyName))
.Append(" FOREIGN KEY (")
.Append(addForeignKeyOperation.ColumnNames.Select(n => DelimitIdentifier(n)).Join())
.Append(") REFERENCES ")
.Append(DelimitIdentifier(addForeignKeyOperation.ReferencedTableName))
.Append(" (")
.Append(addForeignKeyOperation.ReferencedColumnNames.Select(n => DelimitIdentifier(n)).Join())
.Append(")");
if (addForeignKeyOperation.CascadeDelete)
{
stringBuilder.Append(" ON DELETE CASCADE");
}
}
public void FilterOperations_removes_add_foreign_key_when_corresponding_create_table()
{
var friendId = new Column("FriendId", typeof(long));
var id = new Column("Id", typeof(long));
var pony = new Table("Pony", new[] { id, friendId });
pony.AddForeignKey(new ForeignKey("BFFK", new[] { friendId }, new[] { id }));
var createTable = new CreateTableOperation(pony);
var addForeignKey = new AddForeignKeyOperation(
"Pony",
"BFFK",
new[] { "FriendId" },
"Pony",
new[] { "Id" },
false);
var operations = new MigrationOperation[] { createTable, addForeignKey };
var generator = CreateGenerator();
var result = generator.FilterOperations(operations);
Assert.Equal(new[] { createTable }, result);
}
protected override void Generate(AddForeignKeyOperation addForeignKeyOperation)
{
NotNull(addForeignKeyOperation, "addForeignKeyOperation");
using (var writer = Writer())
{
writer.Write("IF NOT EXISTS (SELECT 1 FROM sys.foreign_keys WHERE parent_object_id = OBJECT_ID(N'");
writer.Write(Name(addForeignKeyOperation.DependentTable));
writer.Write("') AND referenced_object_id = OBJECT_ID('");
writer.Write(Name(addForeignKeyOperation.PrincipalTable));
writer.WriteLine("'))");
writer.WriteLine("BEGIN");
writer.Indent++;
writer.Write("ALTER TABLE ");
writer.Write(Name(addForeignKeyOperation.DependentTable));
writer.Write(" ADD CONSTRAINT ");
writer.Write(Quote(addForeignKeyOperation.Name));
writer.Write(" FOREIGN KEY (");
writer.Write(Join(addForeignKeyOperation.DependentColumns.Select(Quote)));
writer.Write(") REFERENCES ");
writer.Write(Name(addForeignKeyOperation.PrincipalTable));
writer.Write(" (");
writer.Write(Join(addForeignKeyOperation.PrincipalColumns.Select(Quote)));
writer.Write(")");
if (addForeignKeyOperation.CascadeDelete)
{
writer.Write(" ON DELETE CASCADE");
}
writer.WriteLine("");
writer.Indent--;
writer.WriteLine("END");
Statement(writer);
}
}
public void Visit_with_create_table_operation_followed_by_unsupported_table_subordinate_operation()
{
var modelBuilder = new BasicModelBuilder();
modelBuilder.Entity("T1",
b =>
{
b.Property <int>("Id");
b.Key("Id");
});
var operation
= new CreateTableOperation(
new Table("T2", new[]
{
new Column("C", typeof(int))
}));
var addForeignKeyOperation
= new AddForeignKeyOperation("T2", "FK", new[] { "C" }, "T1", new[] { "Id" }, cascadeDelete: true);
var operations = PreProcess(modelBuilder, operation, addForeignKeyOperation);
Assert.Equal(1, operations.Count);
Assert.IsType <CreateTableOperation>(operations[0]);
var createTableOperation = (CreateTableOperation)operations[0];
Assert.NotSame(operation, createTableOperation);
Assert.NotSame(operation.Table, createTableOperation.Table);
Assert.Equal("T2", createTableOperation.Table.Name);
Assert.Equal(new[] { "C" }, createTableOperation.Table.Columns.Select(c => c.Name));
Assert.Equal(new[] { typeof(int) }, createTableOperation.Table.Columns.Select(c => c.ClrType));
Assert.Equal(1, createTableOperation.Table.ForeignKeys.Count);
Assert.Equal("FK", createTableOperation.Table.ForeignKeys[0].Name);
Assert.Equal("T1", createTableOperation.Table.ForeignKeys[0].ReferencedTable.Name);
Assert.Equal(new[] { "C" }, createTableOperation.Table.ForeignKeys[0].Columns.Select(c => c.Name));
Assert.Equal(new[] { "Id" }, createTableOperation.Table.ForeignKeys[0].ReferencedColumns.Select(c => c.Name));
}
public virtual TableBuilder <TColumns> ForeignKey(
[NotNull] string name,
[NotNull] Expression <Func <TColumns, object> > foreignKeyExpression,
[NotNull] string referencedTableName,
[NotNull] IReadOnlyList <string> referencedColumnNames,
bool cascadeDelete = false)
{
Check.NotEmpty(name, "name");
Check.NotNull(foreignKeyExpression, "foreignKeyExpression");
Check.NotEmpty(referencedTableName, "referencedTableName");
Check.NotNull(referencedColumnNames, "referencedColumnNames");
var table = _createTableOperation.Table;
var columnNames = foreignKeyExpression.GetPropertyAccessList()
.Select(p => _propertyInfoToColumnMap[p].Name)
.ToArray();
var addForeignKeyOperation = new AddForeignKeyOperation(table.Name, name,
columnNames, referencedTableName, referencedColumnNames, cascadeDelete);
_migrationBuilder.AddOperation(addForeignKeyOperation);
return(this);
}
public override void Generate(AddForeignKeyOperation addForeignKeyOperation, IndentedStringBuilder stringBuilder, bool generateIdempotentSql)
{
Check.NotNull(addForeignKeyOperation, "addForeignKeyOperation");
Check.NotNull(stringBuilder, "stringBuilder");
if (generateIdempotentSql)
{
GenerateForeignKeyPresenceCheck(
addForeignKeyOperation.TableName,
addForeignKeyOperation.ForeignKeyName,
negative: true,
builder: stringBuilder);
using (stringBuilder.AppendLine().Indent())
{
base.Generate(addForeignKeyOperation, stringBuilder, generateIdempotentSql: false);
}
}
else
{
base.Generate(addForeignKeyOperation, stringBuilder, generateIdempotentSql);
}
}
protected virtual void GenerateForeignKey(
[NotNull] AddForeignKeyOperation foreignKeyOperation,
[NotNull] IndentedStringBuilder stringBuilder)
{
Check.NotNull(foreignKeyOperation, "foreignKeyOperation");
Check.NotNull(stringBuilder, "stringBuilder");
stringBuilder
.Append("CONSTRAINT ")
.Append(DelimitIdentifier(foreignKeyOperation.ForeignKeyName))
.Append(" FOREIGN KEY (")
.Append(foreignKeyOperation.ColumnNames.Select(DelimitIdentifier).Join())
.Append(") REFERENCES ")
.Append(DelimitIdentifier(foreignKeyOperation.ReferencedTableName))
.Append(" (")
.Append(foreignKeyOperation.ReferencedColumnNames.Select(DelimitIdentifier).Join())
.Append(")");
if (foreignKeyOperation.CascadeDelete)
{
stringBuilder.Append(" ON DELETE CASCADE");
}
}
protected virtual void ForeignKeyConstraint(
[NotNull] AddForeignKeyOperation operation,
[CanBeNull] IModel model,
[NotNull] RelationalCommandListBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
if (operation.Name != null)
{
builder
.Append("CONSTRAINT ")
.Append(SqlGenerator.DelimitIdentifier(operation.Name))
.Append(" ");
}
builder
.Append("FOREIGN KEY (")
.Append(ColumnList(operation.Columns))
.Append(") REFERENCES ")
.Append(SqlGenerator.DelimitIdentifier(operation.PrincipalTable, operation.PrincipalSchema))
.Append(" (")
.Append(ColumnList(operation.PrincipalColumns))
.Append(")");
if (operation.OnUpdate != ReferentialAction.NoAction)
{
builder.Append(" ON UPDATE ");
ForeignKeyAction(operation.OnUpdate, builder);
}
if (operation.OnDelete != ReferentialAction.NoAction)
{
builder.Append(" ON DELETE ");
ForeignKeyAction(operation.OnDelete, builder);
}
}
protected internal void AddForeignKey(string dependentTable,
string[] dependentColumns,
string principalTable,
string[] principalColumns = null,
bool cascadeDelete = false,
string name = null,
string schema = "dbo",
object anonymousArguments = null)
{
RuntimeFailureMethods.Requires(!string.IsNullOrWhiteSpace(dependentTable),
null,
"!string.IsNullOrWhiteSpace(dependentTable)");
RuntimeFailureMethods.Requires(dependentColumns != null, null, "dependentColumns != null");
RuntimeFailureMethods.Requires(dependentColumns.Any(), null, "dependentColumns.Any()");
RuntimeFailureMethods.Requires(!string.IsNullOrWhiteSpace(principalTable),
null,
"!string.IsNullOrWhiteSpace(principalTable)");
dependentTable = string.Format("{0}.{1}", schema, dependentTable);
principalTable = string.Format("{0}.{1}", schema, principalTable);
var addForeignKeyOperation = new AddForeignKeyOperation(anonymousArguments)
{
DependentTable = dependentTable,
PrincipalTable = principalTable,
CascadeDelete = cascadeDelete,
Name = name
};
dependentColumns.Each(c => addForeignKeyOperation.DependentColumns.Add(c)
);
if (principalColumns != null)
{
principalColumns.Each(c => addForeignKeyOperation.PrincipalColumns.Add(c)
);
}
AddOperation(addForeignKeyOperation);
}
public TableBuilder <TColumns> ForeignKey(string principalTable, IEnumerable <string> principalColumns, Expression <Func <TColumns, object> > dependentKeyExpression, bool cascadeDelete = false, string name = null,
object anonymousArguments = null)
{
RuntimeFailureMethods.Requires(!string.IsNullOrWhiteSpace(principalTable), null, "!string.IsNullOrWhiteSpace(principalTable)");
RuntimeFailureMethods.Requires(dependentKeyExpression != null, null, "dependentKeyExpression != null");
var addForeignKeyOperation = new AddForeignKeyOperation(anonymousArguments)
{
Name = name,
PrincipalTable = principalTable,
DependentTable = this._createTableOperation.Name,
CascadeDelete = cascadeDelete
};
if (principalColumns != null)
{
principalColumns.Each(addForeignKeyOperation.PrincipalColumns.Add);
}
(
dependentKeyExpression.GetPropertyAccessList().Select(p => p.First().Name)).Each(
c => addForeignKeyOperation.DependentColumns.Add(c)
);
this._migration.AddOperation(addForeignKeyOperation);
return(this);
}
protected override void ForeignKeyConstraint(AddForeignKeyOperation operation, IModel model, MigrationCommandListBuilder builder)
{
if (operation.Name != null)
{
builder
.Append("CONSTRAINT ")
.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Name))
.Append(" ");
}
builder
.Append("FOREIGN KEY (")
.Append(ColumnList(operation.Columns))
.Append(") REFERENCES ")
.Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.PrincipalTable, operation.PrincipalSchema));
if (operation.PrincipalColumns != null)
{
builder
.Append(" (")
.Append(ColumnList(operation.PrincipalColumns))
.Append(")");
}
if (operation.OnUpdate != ReferentialAction.NoAction)
{
builder.Append(" ON UPDATE ");
ForeignKeyAction(operation.OnUpdate, builder);
}
if (operation.OnDelete != ReferentialAction.NoAction)
{
builder.Append(" ON DELETE ");
ForeignKeyAction(operation.OnDelete, builder);
}
}
protected internal void AddForeignKey(
string dependentTable,
string[] dependentColumns,
string principalTable,
string[] principalColumns = null,
bool cascadeDelete = false,
string name = null,
object anonymousArguments = null)
{
Check.NotEmpty(dependentTable, "dependentTable");
Check.NotNull(dependentColumns, "dependentColumns");
Check.NotEmpty(principalTable, "principalTable");
if (!dependentColumns.Any())
{
throw new ArgumentException(Strings.CollectionEmpty("dependentColumns", "AddForeignKey"));
}
var addForeignKeyOperation
= new AddForeignKeyOperation(anonymousArguments)
{
DependentTable = dependentTable,
PrincipalTable = principalTable,
CascadeDelete = cascadeDelete,
Name = name
};
dependentColumns.Each(c => addForeignKeyOperation.DependentColumns.Add(c));
if (principalColumns != null)
{
principalColumns.Each(c => addForeignKeyOperation.PrincipalColumns.Add(c));
}
AddOperation(addForeignKeyOperation);
}
/// <summary>
/// Generates a migration operation to add a foreign key.
/// </summary>
/// <param name="op">the operation that represents a foreing key constraint being added to a table.</param>
/// <returns>A migration operation to add a foreign key constraint.</returns>
protected virtual MigrationStatement Generate(AddForeignKeyOperation op)
{
StringBuilder sb = new StringBuilder();
string fkName = op.Name;
if (fkName.Length > 64)
{
fkName = "FK_" + Guid.NewGuid().ToString().Replace("-", "");
}
sb.Append("alter table `" + TrimSchemaPrefix(op.DependentTable) + "` add constraint `" + TrimSchemaPrefix(fkName) + "` " +
" foreign key ");
sb.Append("(" + string.Join(",", op.DependentColumns.Select(c => "`" + c + "`")) + ") ");
sb.Append("references `" + TrimSchemaPrefix(op.PrincipalTable) + "` ( " + string.Join(",", op.PrincipalColumns.Select(c => "`" + c + "`")) + ") ");
if (op.CascadeDelete)
{
sb.Append(" on update cascade on delete cascade ");
}
return(new MigrationStatement {
Sql = sb.ToString()
});
}
public virtual OperationBuilder <AddForeignKeyOperation> AddForeignKey(string name, string table, string[] columns, string principalTable, string schema = null, string principalSchema = null, string[] principalColumns = null, ReferentialAction onUpdate = ReferentialAction.NoAction, ReferentialAction onDelete = ReferentialAction.NoAction)
{
Check.NotEmpty(name, nameof(name));
Check.NotEmpty(table, nameof(table));
Check.NotEmpty(columns, nameof(columns));
Check.NotEmpty(principalTable, nameof(principalTable));
var operation = new AddForeignKeyOperation
{
Schema = schema,
Table = table,
Name = name,
Columns = columns,
PrincipalSchema = principalSchema,
PrincipalTable = principalTable,
PrincipalColumns = principalColumns,
OnUpdate = onUpdate,
OnDelete = onDelete
};
Operations.Add(operation);
return(new OperationBuilder <AddForeignKeyOperation>(operation));
}
public abstract void Generate([NotNull] AddForeignKeyOperation addForeignKeyOperation, [NotNull] IndentedStringBuilder stringBuilder);
public void Table_operation_order_is_retained()
{
var modelBuilder = new BasicModelBuilder();
modelBuilder.Entity("T1",
b =>
{
b.Property <int>("Id");
b.Property <string>("P");
b.Key("Id");
});
modelBuilder.Entity("T2",
b =>
{
b.Property <int>("Id");
b.Key("Id");
});
var createTableOperation
= new CreateTableOperation(
new Table("T3", new[]
{
new Column("C", typeof(int))
}));
var addForeignKeyOperation
= new AddForeignKeyOperation("T3", "FK", new[] { "C" }, "T1", new[] { "Id" }, cascadeDelete: true);
var addColumnOperation = new AddColumnOperation("T2", new Column("C", typeof(string)));
var dropColumOperation = new DropColumnOperation("T1", "P");
var operations = PreProcess(modelBuilder, createTableOperation, addForeignKeyOperation, addColumnOperation, dropColumOperation);
Assert.Equal(6, operations.Count);
Assert.IsType <CreateTableOperation>(operations[0]);
Assert.IsType <AddColumnOperation>(operations[1]);
Assert.IsType <RenameTableOperation>(operations[2]);
Assert.IsType <CreateTableOperation>(operations[3]);
Assert.IsType <CopyDataOperation>(operations[4]);
Assert.IsType <DropTableOperation>(operations[5]);
var createTableOperation1 = (CreateTableOperation)operations[0];
Assert.Equal("T3", createTableOperation1.Table.Name);
Assert.Equal(1, createTableOperation1.Table.ForeignKeys.Count);
Assert.Equal("FK", createTableOperation1.Table.ForeignKeys[0].Name);
Assert.Same(addColumnOperation, operations[1]);
var renameTableOperation = (RenameTableOperation)operations[2];
Assert.Equal("T1", renameTableOperation.TableName);
Assert.Equal("__mig_tmp__T1", renameTableOperation.NewTableName);
var createTableOperation2 = (CreateTableOperation)operations[3];
Assert.Equal("T1", createTableOperation2.Table.Name);
Assert.Equal(new[] { "Id" }, createTableOperation2.Table.Columns.Select(c => c.Name));
var copyDataOperation = (CopyDataOperation)operations[4];
Assert.Equal("__mig_tmp__T1", copyDataOperation.SourceTableName);
Assert.Equal(new[] { "Id" }, copyDataOperation.SourceColumnNames);
Assert.Equal("T1", copyDataOperation.TargetTableName);
Assert.Equal(new[] { "Id" }, copyDataOperation.TargetColumnNames);
var dropTableOperation = (DropTableOperation)operations[5];
Assert.Equal("__mig_tmp__T1", dropTableOperation.TableName);
}
protected override MigrationStatement Generate(AddForeignKeyOperation addForeignKeyOperation)
{
addForeignKeyOperation.PrincipalTable = addForeignKeyOperation.PrincipalTable.Replace("Vendas.", "");
addForeignKeyOperation.DependentTable = addForeignKeyOperation.DependentTable.Replace("Vendas.", "");
return(base.Generate(addForeignKeyOperation));
}
protected override void Generate(AddForeignKeyOperation operation, IModel model, MigrationCommandListBuilder builder, bool terminate = true) => base.Generate(operation, model, builder, terminate);
protected virtual void Generate([NotNull] AddForeignKeyOperation operation, [NotNull] IndentedStringBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
builder.AppendLine(".AddForeignKey(");
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(
operation.Columns.Length == 1
? "column: "
: "columns: ")
.Append(_code.Literal(operation.Columns));
if (operation.ReferencedSchema != null)
{
builder
.AppendLine(",")
.Append("referencedSchema: ")
.Append(_code.Literal(operation.ReferencedSchema));
}
builder
.AppendLine(",")
.Append("referencedTable: ")
.Append(_code.Literal(operation.ReferencedTable));
if (operation.ReferencedColumns != null)
{
builder
.AppendLine(",")
.Append(
operation.ReferencedColumns.Length == 1
? "referencedColumn: "
: "referencedColumns: ")
.Append(_code.Literal(operation.ReferencedColumns));
}
if (operation.OnUpdate != ReferentialAction.NoAction)
{
builder
.AppendLine(",")
.Append("onUpdate: ")
.Append(_code.Literal(operation.OnUpdate));
}
if (operation.OnDelete != ReferentialAction.NoAction)
{
builder
.AppendLine(",")
.Append("onDelete: ")
.Append(_code.Literal(operation.OnDelete));
}
builder.Append(")");
Annotations(operation.Annotations, builder);
}
}
public void Generate_can_output_create_table_statement()
{
var createTableOperation = new CreateTableOperation("Customers");
var idColumn = new ColumnModel(PrimitiveTypeKind.Int32)
{
Name = "I.d",
IsNullable = true,
IsIdentity = true
};
createTableOperation.Columns.Add(idColumn);
createTableOperation.Columns.Add(
new ColumnModel(PrimitiveTypeKind.String)
{
Name = "Name",
IsNullable = false
});
createTableOperation.PrimaryKey = new AddPrimaryKeyOperation
{
Name = "MyPK"
};
createTableOperation.PrimaryKey.Columns.Add(idColumn.Name);
var codeGenerator = new VisualBasicMigrationCodeGenerator();
var addForeignKeyOperation = new AddForeignKeyOperation
{
DependentTable = "Customers",
PrincipalTable = "Blogs",
CascadeDelete = true
};
addForeignKeyOperation.DependentColumns.Add("Blog.Id");
addForeignKeyOperation.PrincipalColumns.Add("Id");
var generatedMigration
= codeGenerator.Generate(
"Migration",
new MigrationOperation[]
{
createTableOperation,
addForeignKeyOperation,
addForeignKeyOperation.CreateCreateIndexOperation()
},
"Source",
"Target",
"Foo",
"Bar");
Assert.Equal(
@"Imports System
Imports System.Data.Entity.Migrations
Imports Microsoft.VisualBasic
Namespace Foo
Public Partial Class Bar
Inherits DbMigration
Public Overrides Sub Up()
CreateTable(
""Customers"",
Function(c) New With
{
.Id = c.Int(name := ""I.d"", identity := True),
.Name = c.String(nullable := False)
}) _
.PrimaryKey(Function(t) t.Id, name := ""MyPK"") _
.ForeignKey(""Blogs"", Function(t) t.BlogId, cascadeDelete := True) _
.Index(Function(t) t.BlogId)
End Sub
Public Overrides Sub Down()
DropIndex(""Customers"", New String() { ""Blog.Id"" })
DropForeignKey(""Customers"", ""Blog.Id"", ""Blogs"")
DropTable(""Customers"")
End Sub
End Class
End Namespace
",
generatedMigration.UserCode);
Assert.Equal(
@"' <auto-generated />
Imports System.CodeDom.Compiler
Imports System.Data.Entity.Migrations
Imports System.Data.Entity.Migrations.Infrastructure
Imports System.Resources
Namespace Foo
<GeneratedCode(""EntityFramework.Migrations"", """ + typeof(DbContext).Assembly().GetInformationalVersion() + @""")>
Public NotInheritable Partial Class Bar
Implements IMigrationMetadata
Private ReadOnly Resources As New ResourceManager(GetType(Bar))
Private ReadOnly Property IMigrationMetadata_Id() As String Implements IMigrationMetadata.Id
Get
Return ""Migration""
End Get
End Property
Private ReadOnly Property IMigrationMetadata_Source() As String Implements IMigrationMetadata.Source
Get
Return Resources.GetString(""Source"")
End Get
End Property
Private ReadOnly Property IMigrationMetadata_Target() As String Implements IMigrationMetadata.Target
Get
Return Resources.GetString(""Target"")
End Get
End Property
End Class
End Namespace
",
generatedMigration.DesignerCode);
Assert.Equal("vb", generatedMigration.Language);
Assert.Equal(2, generatedMigration.Resources.Count);
Assert.Equal("Source", generatedMigration.Resources["Source"]);
Assert.Equal("Target", generatedMigration.Resources["Target"]);
}
protected virtual void Generate(
[NotNull] AddForeignKeyOperation operation,
[CanBeNull] IModel model,
[NotNull] MigrationCommandListBuilder builder)
=> Generate(operation, model, builder, terminate: true);
public void CreateForeignKeyOperation()
{
var migrationOperations = new List <MigrationOperation>();
// create dependant table Posts
var createTableOperation = CreateTableOperation();
migrationOperations.Add(createTableOperation);
// Add column BlogId to create the constraints
if (ProviderManifest == null)
{
ProviderManifest = new MySqlProviderManifest(st.Version.ToString());
}
TypeUsage tu = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32));
TypeUsage result = ProviderManifest.GetStoreType(tu);
var intColumn = new ColumnModel(PrimitiveTypeKind.Int32, result)
{
Name = "BlogId",
IsNullable = false
};
var addColumnMigratioOperation = new AddColumnOperation("Posts", intColumn);
migrationOperations.Add(addColumnMigratioOperation);
// create constrain object
var createForeignkeyOperation = new AddForeignKeyOperation();
createForeignkeyOperation.Name = "FKBlogs";
createForeignkeyOperation.DependentTable = "Posts";
createForeignkeyOperation.DependentColumns.Add("BlogId");
createForeignkeyOperation.CascadeDelete = true;
createForeignkeyOperation.PrincipalTable = "Blogs";
createForeignkeyOperation.PrincipalColumns.Add("BlogId");
//create index to use
migrationOperations.Add(createForeignkeyOperation.CreateCreateIndexOperation());
migrationOperations.Add(createForeignkeyOperation);
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 foreign key creation
MySqlCommand query = new MySqlCommand("select Count(*) from information_schema.table_constraints where constraint_type = 'foreign key' and constraint_schema = '" + conn.Database + "' and constraint_name = 'FKBlogs'", conn);
int rows = Convert.ToInt32(query.ExecuteScalar());
Assert.Equal(1, rows);
// check for table creation
query = new MySqlCommand("select Count(*) from information_schema.Tables WHERE `table_name` = 'Posts' and `table_schema` = '" + conn.Database + "' ", conn);
rows = Convert.ToInt32(query.ExecuteScalar());
Assert.Equal(1, rows);
conn.Close();
}
// Test fix for
MySqlConnection con = GetConnectionFromContext(context);
con.Open();
try
{
MySqlCommand cmd = new MySqlCommand("show create table `posts`", con);
using (MySqlDataReader r = cmd.ExecuteReader())
{
r.Read();
string sql = r.GetString(1);
Assert.True(sql.IndexOf(
" CONSTRAINT `FKBlogs` FOREIGN KEY (`BlogId`) REFERENCES `blogs` (`BlogId`) ON DELETE CASCADE ON UPDATE CASCADE",
StringComparison.OrdinalIgnoreCase) != -1);
}
}
finally
{
con.Close();
}
}
}
public void Generate_can_output_create_table_statement()
{
var createTableOperation = new CreateTableOperation("Customers");
var idColumn = new ColumnModel(PrimitiveTypeKind.Int32)
{
Name = "I.d",
IsNullable = true,
IsIdentity = true
};
createTableOperation.Columns.Add(idColumn);
createTableOperation.Columns.Add(
new ColumnModel(PrimitiveTypeKind.String)
{
Name = "Name",
IsNullable = false
});
createTableOperation.PrimaryKey = new AddPrimaryKeyOperation
{
Name = "MyPK"
};
createTableOperation.PrimaryKey.Columns.Add(idColumn.Name);
var codeGenerator = new CSharpMigrationCodeGenerator();
var addForeignKeyOperation = new AddForeignKeyOperation
{
DependentTable = "Customers",
PrincipalTable = "Blogs",
CascadeDelete = true
};
addForeignKeyOperation.DependentColumns.Add("Blog.Id");
addForeignKeyOperation.PrincipalColumns.Add("Id");
var generatedMigration
= codeGenerator.Generate(
"Migration",
new MigrationOperation[]
{
createTableOperation,
addForeignKeyOperation,
addForeignKeyOperation.CreateCreateIndexOperation()
},
"Source",
"Target",
"Foo",
"Bar");
Assert.Equal(
@"namespace Foo
{
using System;
using System.Data.Entity.Migrations;
public partial class Bar : DbMigration
{
public override void Up()
{
CreateTable(
""Customers"",
c => new
{
Id = c.Int(name: ""I.d"", identity: true),
Name = c.String(nullable: false),
})
.PrimaryKey(t => t.Id, name: ""MyPK"")
.ForeignKey(""Blogs"", t => t.BlogId, cascadeDelete: true)
.Index(t => t.BlogId);
}
public override void Down()
{
DropIndex(""Customers"", new[] { ""Blog.Id"" });
DropForeignKey(""Customers"", ""Blog.Id"", ""Blogs"");
DropTable(""Customers"");
}
}
}
",
generatedMigration.UserCode);
Assert.Equal(
@"// <auto-generated />
namespace Foo
{
using System.CodeDom.Compiler;
using System.Data.Entity.Migrations;
using System.Data.Entity.Migrations.Infrastructure;
using System.Resources;
[GeneratedCode(""EntityFramework.Migrations"", """ + typeof(DbContext).Assembly.GetInformationalVersion() + @""")]
public sealed partial class Bar : IMigrationMetadata
{
private readonly ResourceManager Resources = new ResourceManager(typeof(Bar));
string IMigrationMetadata.Id
{
get { return ""Migration""; }
}
string IMigrationMetadata.Source
{
get { return Resources.GetString(""Source""); }
}
string IMigrationMetadata.Target
{
get { return Resources.GetString(""Target""); }
}
}
}
",
generatedMigration.DesignerCode);
Assert.Equal("cs", generatedMigration.Language);
Assert.Equal(2, generatedMigration.Resources.Count);
Assert.Equal("Source", generatedMigration.Resources["Source"]);
Assert.Equal("Target", generatedMigration.Resources["Target"]);
}
// These operations can be accomplished instead with a table-rebuild
protected override void Generate(AddForeignKeyOperation operation, IModel model, MigrationCommandListBuilder builder)
{
throw new NotSupportedException(SqliteStrings.InvalidMigrationOperation(operation.GetType().ShortDisplayName()));
}
//For removal of dbo. during addition of foreign key's convention
protected override void Generate(AddForeignKeyOperation addForeignKeyOperation, IndentedTextWriter writer)
{
addForeignKeyOperation.Name = this.StripDbo(addForeignKeyOperation.Name, addForeignKeyOperation.DependentTable);
addForeignKeyOperation.Name = this.StripDbo(addForeignKeyOperation.Name, addForeignKeyOperation.PrincipalTable);
base.Generate(addForeignKeyOperation, writer);
}
protected override void Generate(AddForeignKeyOperation addForeignKeyOperation)
{
addForeignKeyOperation.DependentTable = getNameWithReplacedSchema(addForeignKeyOperation.DependentTable);
addForeignKeyOperation.PrincipalTable = getNameWithReplacedSchema(addForeignKeyOperation.PrincipalTable);
base.Generate(addForeignKeyOperation);
}
protected virtual void Generate(AddForeignKeyOperation opeChaveEstrangeira)
{
// Inicialmente não havera a criação de chave estrangeira
}
protected override void Generate(AddForeignKeyOperation operation, IModel model, MigrationCommandListBuilder builder) => base.Generate(operation, model, builder);
