public void Get_generation_property_returns_generation_property_from_foreign_key_tree()
{
var model = new Model();
var leftType = new EntityType("Left", model);
var leftId = leftType.AddProperty("Id", typeof(int), true);
var leftKey = leftType.AddKey(leftId);
var rightType = new EntityType("Right", model);
var rightId1 = rightType.AddProperty("Id1", typeof(int), true);
var rightId2 = rightType.AddProperty("Id2", typeof(int), true);
var rightKey = rightType.AddKey(new[] { rightId1, rightId2 });
var middleType = new EntityType("Middle", model);
var middleProperty1 = middleType.AddProperty("FK1", typeof(int), true);
var middleProperty2 = middleType.AddProperty("FK2", typeof(int), true);
var middleKey1 = middleType.AddKey(middleProperty1);
var middleFK1 = middleType.AddForeignKey(middleProperty1, leftKey);
var middleFK2 = middleType.AddForeignKey(new[] { middleProperty2, middleProperty1 }, rightKey);
var endType = new EntityType("End", model);
var endProperty = endType.AddProperty("FK", typeof(int), true);
var endFK = endType.AddForeignKey(endProperty, middleKey1);
rightId2.GenerateValueOnAdd = true;
Assert.Equal(rightId2, endProperty.GetGenerationProperty());
}
public void Get_generation_property_returns_generation_property_from_foreign_key_graph_with_cycle()
{
var model = new Model();
var leafType = new EntityType("leaf", model);
var leafId1 = leafType.AddProperty("Id1", typeof(int), true);
var leafId2 = leafType.AddProperty("Id2", typeof(int), true);
var leafKey = leafType.AddKey(new[] { leafId1, leafId2 });
var firstType = new EntityType("First", model);
var firstId = firstType.AddProperty("Id", typeof(int), true);
var firstKey = firstType.AddKey(firstId);
var secondType = new EntityType("Second", model);
var secondId1 = secondType.AddProperty("Id1", typeof(int), true);
var secondId2 = secondType.AddProperty("Id2", typeof(int), true);
var secondKey = secondType.AddKey(secondId1);
var firstForeignKey = firstType.AddForeignKey(firstId, secondKey);
var secondForeignKey1 = secondType.AddForeignKey(secondId1, firstKey);
var secondForeignKey2 = secondType.AddForeignKey(new[] { secondId1, secondId2 }, leafKey);
leafId1.GenerateValueOnAdd = true;
Assert.Equal(leafId1, secondId1.GetGenerationProperty());
}
public void Get_generation_property_returns_generation_property_from_foreign_key_tree()
{
var model = new Model();
var leftType = new EntityType("Left", model);
var leftId = leftType.AddProperty("Id", typeof(int), true);
var leftKey = leftType.AddKey(leftId);
var rightType = new EntityType("Right", model);
var rightId1 = rightType.AddProperty("Id1", typeof(int), true);
var rightId2 = rightType.AddProperty("Id2", typeof(int), true);
var rightKey = rightType.AddKey(new[] { rightId1, rightId2 });
var middleType = new EntityType("Middle", model);
var middleProperty1 = middleType.AddProperty("FK1", typeof(int), true);
var middleProperty2 = middleType.AddProperty("FK2", typeof(int), true);
var middleKey1 = middleType.AddKey(middleProperty1);
var middleFK1 = middleType.AddForeignKey(middleProperty1, leftKey, leftType);
var middleFK2 = middleType.AddForeignKey(new[] { middleProperty2, middleProperty1 }, rightKey, rightType);
var endType = new EntityType("End", model);
var endProperty = endType.AddProperty("FK", typeof(int), true);
var endFK = endType.AddForeignKey(endProperty, middleKey1, middleType);
rightId2.RequiresValueGenerator = true;
Assert.Equal(rightId2, endProperty.GetGenerationProperty());
}
public void Sort_tree()
{
var entityTypeA = new EntityType(typeof(A));
entityTypeA.SetKey(entityTypeA.AddProperty("Id", typeof(int), shadowProperty: true, concurrencyToken: false));
var entityTypeB = new EntityType(typeof(B));
entityTypeB.SetKey(entityTypeB.AddProperty("Id", typeof(int), shadowProperty: true, concurrencyToken: false));
var entityTypeC = new EntityType(typeof(C));
entityTypeC.SetKey(entityTypeC.AddProperty("Id", typeof(int), shadowProperty: true, concurrencyToken: false));
var model = new Model();
model.AddEntityType(entityTypeA);
model.AddEntityType(entityTypeB);
model.AddEntityType(entityTypeC);
// A -> B, C -> B
entityTypeB.AddForeignKey(entityTypeA.GetKey(), entityTypeB.AddProperty("P", typeof(int)));
entityTypeC.AddForeignKey(entityTypeA.GetKey(), entityTypeC.AddProperty("P", typeof(int)));
entityTypeB.AddForeignKey(entityTypeC.GetKey(), entityTypeB.AddProperty("P", typeof(int)));
Assert.Equal(
new IEntityType[] { entityTypeA, entityTypeC, entityTypeB },
model.TopologicalSort().ToArray());
}
/// <summary>
/// Moves a foreign key constraint from oldTable to newTable and updates column references
/// </summary>
private static void MoveForeignKeyConstraint(
EntityType fromTable, EntityType toTable, ForeignKeyBuilder fk)
{
DebugCheck.NotNull(fromTable);
DebugCheck.NotNull(toTable);
DebugCheck.NotNull(fk);
fromTable.RemoveForeignKey(fk);
// Only move it to the new table if the destination is not the principal table or if all dependent columns are not FKs
// Otherwise you end up with an FK from the PKs to the PKs of the same table
if (fk.PrincipalTable != toTable ||
!fk.DependentColumns.All(c => c.IsPrimaryKeyColumn))
{
// Make sure all the dependent columns refer to columns in the newTable
var oldColumns = fk.DependentColumns.ToArray();
var dependentColumns
= GetDependentColumns(oldColumns, toTable.Properties);
if (!ContainsEquivalentForeignKey(toTable, fk.PrincipalTable, dependentColumns))
{
toTable.AddForeignKey(fk);
fk.DependentColumns = dependentColumns;
}
}
}
public void Diff_finds_dropped_table()
{
var sourceModel = CreateModel();
var targetModel = CreateModel();
var principalEntityType = targetModel.GetEntityType("Principal");
var dependentEntityType = new EntityType("OldDependent")
{
StorageName = "dbo.MyOldTable"
};
var dependentProperty = dependentEntityType.AddProperty("Id", typeof(int));
sourceModel.AddEntityType(dependentEntityType);
dependentProperty.Annotations.Add(new Annotation(
MetadataExtensions.Annotations.StorageTypeName, "int"));
dependentEntityType.SetKey(dependentProperty);
dependentEntityType.GetKey().StorageName = "MyOldPK";
var foreignKey = dependentEntityType.AddForeignKey(principalEntityType.GetKey(), dependentProperty);
foreignKey.StorageName = "MyOldFK";
foreignKey.Annotations.Add(new Annotation(
MetadataExtensions.Annotations.CascadeDelete, "True"));
var operations = new ModelDiffer(new DatabaseBuilder()).Diff(sourceModel, targetModel);
Assert.Equal(1, operations.Count);
Assert.IsType <DropTableOperation>(operations[0]);
var dropTableOperation = (DropTableOperation)operations[0];
Assert.Equal("dbo.MyOldTable", dropTableOperation.TableName);
}
public void Sort_circular_transitive()
{
var entityTypeA = new EntityType(typeof(A));
entityTypeA.SetKey(entityTypeA.AddProperty("Id", typeof(int), shadowProperty: true, concurrencyToken: false));
var entityTypeB = new EntityType(typeof(B));
entityTypeB.SetKey(entityTypeB.AddProperty("Id", typeof(int), shadowProperty: true, concurrencyToken: false));
var entityTypeC = new EntityType(typeof(C));
entityTypeC.SetKey(entityTypeC.AddProperty("Id", typeof(int), shadowProperty: true, concurrencyToken: false));
var model = new Model();
model.AddEntityType(entityTypeA);
model.AddEntityType(entityTypeB);
model.AddEntityType(entityTypeC);
// A -> B -> C -> A
entityTypeA.AddForeignKey(entityTypeB.GetKey(), entityTypeA.AddProperty("P", typeof(int)));
entityTypeB.AddForeignKey(entityTypeC.GetKey(), entityTypeB.AddProperty("P", typeof(int)));
entityTypeC.AddForeignKey(entityTypeA.GetKey(), entityTypeC.AddProperty("P", typeof(int)));
Assert.Equal(
Strings.FormatCircularDependency("A -> B -> C -> A"),
Assert.Throws <InvalidOperationException>(() => model.TopologicalSort()).Message);
}
internal override void Configure(
AssociationSetMapping associationSetMapping,
EdmModel database,
PropertyInfo navigationProperty)
{
List <ScalarPropertyMapping> propertyMappings = associationSetMapping.SourceEndMapping.PropertyMappings.ToList <ScalarPropertyMapping>();
if (this._tableName != null)
{
EntityType targetTable = database.EntityTypes.Select(t => new
{
t = t,
n = t.GetTableName()
}).Where(_param1 =>
{
if (_param1.n != null)
{
return(_param1.n.Equals(this._tableName));
}
return(false);
}).Select(_param0 => _param0.t).SingleOrDefault <EntityType>() ?? database.GetEntitySets().Where <EntitySet>((Func <EntitySet, bool>)(es => string.Equals(es.Table, this._tableName.Name, StringComparison.Ordinal))).Select <EntitySet, EntityType>((Func <EntitySet, EntityType>)(es => es.ElementType)).SingleOrDefault <EntityType>();
if (targetTable == null)
{
throw Error.TableNotFound((object)this._tableName);
}
EntityType sourceTable = associationSetMapping.Table;
if (sourceTable != targetTable)
{
ForeignKeyBuilder foreignKeyBuilder = sourceTable.ForeignKeyBuilders.Single <ForeignKeyBuilder>((Func <ForeignKeyBuilder, bool>)(fk => fk.DependentColumns.SequenceEqual <EdmProperty>(propertyMappings.Select <ScalarPropertyMapping, EdmProperty>((Func <ScalarPropertyMapping, EdmProperty>)(pm => pm.Column)))));
sourceTable.RemoveForeignKey(foreignKeyBuilder);
targetTable.AddForeignKey(foreignKeyBuilder);
foreignKeyBuilder.DependentColumns.Each <EdmProperty>((Action <EdmProperty>)(c =>
{
bool primaryKeyColumn = c.IsPrimaryKeyColumn;
sourceTable.RemoveMember((EdmMember)c);
targetTable.AddMember((EdmMember)c);
if (!primaryKeyColumn)
{
return;
}
targetTable.AddKeyMember((EdmMember)c);
}));
associationSetMapping.StoreEntitySet = database.GetEntitySet(targetTable);
}
}
if (this._keyColumnNames.Count > 0 && this._keyColumnNames.Count != propertyMappings.Count <ScalarPropertyMapping>())
{
throw Error.IncorrectColumnCount((object)string.Join(", ", (IEnumerable <string>) this._keyColumnNames));
}
this._keyColumnNames.Each <string>((Action <string, int>)((n, i) => propertyMappings[i].Column.Name = n));
foreach (KeyValuePair <Tuple <string, string>, object> annotation in (IEnumerable <KeyValuePair <Tuple <string, string>, object> >) this._annotations)
{
int index = this._keyColumnNames.IndexOf(annotation.Key.Item1);
if (index == -1)
{
throw new InvalidOperationException(Strings.BadKeyNameForAnnotation((object)annotation.Key.Item1, (object)annotation.Key.Item2));
}
propertyMappings[index].Column.AddAnnotation("http://schemas.microsoft.com/ado/2013/11/edm/customannotation:" + annotation.Key.Item2, annotation.Value);
}
}
private static void CopyForeignKeyConstraint(EdmModel database, EntityType toTable, ForeignKeyBuilder fk,
Func <EdmProperty, EdmProperty> selector = null)
{
DebugCheck.NotNull(toTable);
DebugCheck.NotNull(fk);
var newFk
= new ForeignKeyBuilder(
database,
database.EntityTypes.SelectMany(t => t.ForeignKeyBuilders).UniquifyName(fk.Name))
{
PrincipalTable = fk.PrincipalTable,
DeleteAction = fk.DeleteAction
};
newFk.SetPreferredName(fk.Name);
var dependentColumns =
GetDependentColumns(
selector != null
? fk.DependentColumns.Select(selector)
: fk.DependentColumns,
toTable.Properties);
if (!ContainsEquivalentForeignKey(toTable, newFk.PrincipalTable, dependentColumns))
{
toTable.AddForeignKey(newFk);
newFk.DependentColumns = dependentColumns;
}
}
protected ForeignKey CreateForeignKey(EntityType dependEntityType, IReadOnlyList <Property> dependentProperties, Key principalKey)
{
var foreignKey = dependEntityType.AddForeignKey(dependentProperties, principalKey, principalKey.DeclaringEntityType);
foreignKey.IsUnique = true;
return(foreignKey);
}
protected override Model BuildModel()
{
var model = new Model();
var entityType1 = new EntityType(typeof(SomeEntity));
model.AddEntityType(entityType1);
var key1 = entityType1.AddProperty("Id", typeof(int), shadowProperty: true, concurrencyToken: false);
key1.ValueGenerationOnSave = ValueGenerationOnSave.WhenInserting;
key1.ValueGenerationOnAdd = ValueGenerationOnAdd.Client;
entityType1.SetKey(key1);
entityType1.AddProperty("Name", typeof(string));
var entityType2 = new EntityType(typeof(SomeDependentEntity));
model.AddEntityType(entityType2);
var key2a = entityType2.AddProperty("Id1", typeof(int));
var key2b = entityType2.AddProperty("Id2", typeof(string));
entityType2.SetKey(key2a, key2b);
var fk = entityType2.AddProperty("SomeEntityId", typeof(int), shadowProperty: true, concurrencyToken: false);
entityType2.AddForeignKey(entityType1.GetKey(), new[] { fk });
var justAProperty = entityType2.AddProperty("JustAProperty", typeof(int));
justAProperty.ValueGenerationOnSave = ValueGenerationOnSave.WhenInserting;
justAProperty.ValueGenerationOnAdd = ValueGenerationOnAdd.Client;
var entityType3 = new EntityType(typeof(FullNotificationEntity));
model.AddEntityType(entityType3);
entityType3.SetKey(entityType3.AddProperty("Id", typeof(int), shadowProperty: true, concurrencyToken: false));
entityType3.AddProperty("Name", typeof(string), shadowProperty: false, concurrencyToken: true);
var entityType4 = new EntityType(typeof(ChangedOnlyEntity));
model.AddEntityType(entityType4);
entityType4.SetKey(entityType4.AddProperty("Id", typeof(int), shadowProperty: true, concurrencyToken: false));
entityType4.AddProperty("Name", typeof(string), shadowProperty: false, concurrencyToken: true);
var entityType5 = new EntityType(typeof(SomeMoreDependentEntity));
model.AddEntityType(entityType5);
var key5 = entityType5.AddProperty("Id", typeof(int));
entityType5.SetKey(key5);
var fk5a = entityType5.AddProperty("Fk1", typeof(int));
var fk5b = entityType5.AddProperty("Fk2", typeof(string));
entityType5.AddForeignKey(entityType2.GetKey(), new[] { fk5a, fk5b });
return(model);
}
public void Diff_finds_created_table()
{
var sourceModel = CreateModel();
var targetModel = CreateModel();
var principalEntityType = targetModel.GetEntityType("Principal");
var dependentEntityType = new EntityType("NewDependent")
{
StorageName = "dbo.MyNewTable"
};
var dependentProperty = dependentEntityType.AddProperty("Id", typeof(int));
targetModel.AddEntityType(dependentEntityType);
dependentProperty.Annotations.Add(new Annotation(
MetadataExtensions.Annotations.StorageTypeName, "int"));
dependentEntityType.SetKey(dependentProperty);
dependentEntityType.GetKey().StorageName = "MyNewPK";
var foreignKey = dependentEntityType.AddForeignKey(principalEntityType.GetKey(), dependentProperty);
foreignKey.StorageName = "MyNewFK";
foreignKey.Annotations.Add(new Annotation(
MetadataExtensions.Annotations.CascadeDelete, "True"));
var operations = new ModelDiffer(new DatabaseBuilder()).Diff(sourceModel, targetModel);
Assert.Equal(2, operations.Count);
Assert.IsType <CreateTableOperation>(operations[0]);
Assert.IsType <AddForeignKeyOperation>(operations[1]);
var createTableOperation = (CreateTableOperation)operations[0];
Assert.Equal("dbo.MyNewTable", createTableOperation.Table.Name);
Assert.Equal(1, createTableOperation.Table.Columns.Count);
Assert.Equal("Id", createTableOperation.Table.Columns[0].Name);
Assert.Equal(typeof(int), createTableOperation.Table.Columns[0].ClrType);
Assert.NotNull(createTableOperation.Table.PrimaryKey);
Assert.Equal("MyNewPK", createTableOperation.Table.PrimaryKey.Name);
Assert.Equal(1, createTableOperation.Table.ForeignKeys.Count);
Assert.Equal("MyNewFK", createTableOperation.Table.ForeignKeys[0].Name);
Assert.True(createTableOperation.Table.ForeignKeys[0].CascadeDelete);
var addForeignKeyOperation = (AddForeignKeyOperation)operations[1];
Assert.Equal("MyNewFK", addForeignKeyOperation.ForeignKeyName);
Assert.Equal("dbo.MyNewTable", addForeignKeyOperation.TableName);
Assert.Equal("dbo.MyTable1", addForeignKeyOperation.ReferencedTableName);
Assert.Equal(new[] { "Id" }, addForeignKeyOperation.ColumnNames);
Assert.Equal(new[] { "Id" }, addForeignKeyOperation.ReferencedColumnNames);
Assert.True(addForeignKeyOperation.CascadeDelete);
}
protected ForeignKey CreateForeignKey(EntityType dependEntityType, IReadOnlyList <Property> dependentProperties, Key principalKey)
{
var foreignKey = dependEntityType.AddForeignKey(dependentProperties, principalKey, principalKey.DeclaringEntityType);
foreignKey.IsUnique = true;
foreach (var property in dependentProperties)
{
property.RequiresValueGenerator = false;
}
return(foreignKey);
}
public void FK_properties_are_marked_as_requiring_original_values()
{
var entityType = new EntityType(typeof(FullNotificationEntity));
entityType.SetKey(entityType.AddProperty("Id", typeof(int)));
Assert.Equal(-1, entityType.GetProperty("Id").OriginalValueIndex);
entityType.AddForeignKey(entityType.GetKey(), new[] { entityType.AddProperty("Id", typeof(int)) });
Assert.Equal(0, entityType.GetProperty("Id").OriginalValueIndex);
}
private static Metadata.Model CreateModel()
{
var model = new Metadata.Model()
{
StorageName = "MyDatabase"
};
var dependentEntityType = new EntityType("Dependent");
dependentEntityType.SetTableName("MyTable0");
dependentEntityType.SetSchema("dbo");
var principalEntityType = new EntityType("Principal");
principalEntityType.SetTableName("MyTable1");
principalEntityType.SetSchema("dbo");
var dependentProperty = dependentEntityType.AddProperty("Id", typeof(int));
var principalProperty = principalEntityType.AddProperty("Id", typeof(int));
var property = dependentEntityType.AddProperty("MyProperty", typeof(string));
property.SetColumnName("MyColumn");
property = principalEntityType.AddProperty("MyProperty", typeof(string));
property.SetColumnName("MyColumn");
model.AddEntityType(principalEntityType);
model.AddEntityType(dependentEntityType);
principalProperty.Annotations.Add(new Annotation(
MetadataExtensions.Annotations.StorageTypeName, "int"));
dependentProperty.Annotations.Add(new Annotation(
MetadataExtensions.Annotations.StorageTypeName, "int"));
dependentEntityType.SetKey(dependentProperty);
principalEntityType.SetKey(principalProperty);
dependentEntityType.GetKey().SetKeyName("MyPK0");
principalEntityType.GetKey().SetKeyName("MyPK1");
var foreignKey = dependentEntityType.AddForeignKey(principalEntityType.GetKey(), dependentProperty);
foreignKey.SetKeyName("MyFK");
foreignKey.Annotations.Add(new Annotation(
MetadataExtensions.Annotations.CascadeDelete, "True"));
var index = dependentEntityType.AddIndex(dependentProperty);
index.SetIndexName("MyIndex");
index.IsUnique = true;
return(model);
}
public void Setting_foreign_key_properties_should_update_existing_properties()
{
var entityType = new EntityType(typeof(Order));
entityType.SetKey(entityType.AddProperty(Order.CustomerIdProperty));
var newIdProperty = entityType.AddProperty(Order.CustomerIdProperty);
var property2 = entityType.AddProperty(Order.CustomerUniqueProperty);
entityType.AddForeignKey(entityType.GetKey(), new[] { newIdProperty, property2 });
Assert.Equal(new[] { newIdProperty, property2 }, entityType.Properties.ToArray());
}
public void Add_foreign_key()
{
var entityType = new EntityType(typeof(Order));
entityType.SetKey(entityType.AddProperty(Order.IdProperty));
var foreignKey
= entityType.AddForeignKey(
entityType.GetKey(),
new[] { entityType.AddProperty(Order.CustomerUniqueProperty) });
Assert.True(entityType.ForeignKeys.Contains(foreignKey));
}
public virtual ForeignKey FindOrCreateForeignKey(
[NotNull] EntityType principalType,
[NotNull] EntityType dependentType,
[CanBeNull] string navigationToPrincipal,
[CanBeNull] string navigationToDependent,
[NotNull] IReadOnlyList <Property[]> foreignKeyProperties,
bool isUnqiue)
{
Check.NotNull(principalType, "principalType");
Check.NotNull(dependentType, "dependentType");
if (!foreignKeyProperties.Any())
{
foreignKeyProperties = GetCandidateForeignKeyProperties(principalType, dependentType, navigationToPrincipal, isUnqiue);
}
foreach (var properties in foreignKeyProperties)
{
var foreignKey = dependentType
.ForeignKeys
.FirstOrDefault(fk => fk.IsUnique == isUnqiue &&
fk.Properties.SequenceEqual(properties) &&
!fk.EntityType.Navigations.Any(n => n.ForeignKey == fk && n.Name != navigationToPrincipal) &&
!fk.ReferencedEntityType.Navigations.Any(n => n.ForeignKey == fk && n.Name != navigationToDependent));
if (foreignKey != null)
{
return(foreignKey);
}
}
// TODO: Handle case where principal key is not defined
// TODO: What if foreignKey exists but is associated with different navigations
var fkProperty = foreignKeyProperties.FirstOrDefault()
?? new[]
{
dependentType.AddProperty(
(navigationToPrincipal ?? principalType.Name) + "Id",
// TODO: Make nullable
principalType.GetKey().Properties.First().PropertyType,
shadowProperty: true,
concurrencyToken: false)
};
var newForeignKey = dependentType.AddForeignKey(principalType.GetKey(), fkProperty);
newForeignKey.IsUnique = isUnqiue;
return(newForeignKey);
}
private static void CloneForeignKeys(IEntityType sourceEntityType, EntityType targetEntityType)
{
foreach (var foreignKey in sourceEntityType.GetDeclaredForeignKeys())
{
var targetPrincipalEntityType = targetEntityType.Model.FindEntityType(foreignKey.PrincipalEntityType.Name);
var clonedForeignKey = targetEntityType.AddForeignKey(
foreignKey.Properties.Select(p => targetEntityType.FindProperty(p.Name)).ToList(),
targetPrincipalEntityType.FindKey(foreignKey.PrincipalKey.Properties.Select(p => targetPrincipalEntityType.FindProperty(p.Name)).ToList()),
targetPrincipalEntityType);
clonedForeignKey.IsUnique = foreignKey.IsUnique;
clonedForeignKey.IsRequired = foreignKey.IsRequired;
foreignKey.GetAnnotations().ForEach(annotation => clonedForeignKey[annotation.Name] = annotation.Value);
}
}
private static Model BuildModel()
{
var model = new Model();
var entityType = new EntityType(typeof(Banana));
var property1 = entityType.AddProperty("P1", typeof(int));
var property2 = entityType.AddProperty("P2", typeof(string));
entityType.SetKey(property1);
entityType.AddForeignKey(entityType.GetKey(), property2);
model.AddEntityType(entityType);
return(model);
}
private static Model BuildModel()
{
var model = new Model();
var entityType = new EntityType(typeof(Banana));
var idProperty = entityType.AddProperty("Id", typeof(int), shadowProperty: false, concurrencyToken: true);
idProperty.ValueGenerationOnSave = ValueGenerationOnSave.WhenInserting;
entityType.SetKey(idProperty);
entityType.AddProperty("Name", typeof(string));
entityType.AddProperty("State", typeof(string), shadowProperty: false, concurrencyToken: true);
var fkProperty = entityType.AddProperty("Fk", typeof(int?), shadowProperty: false, concurrencyToken: true);
entityType.AddForeignKey(new Key(new[] { idProperty }), fkProperty);
model.AddEntityType(entityType);
var entityType2 = new EntityType(typeof(SomeDependentEntity));
model.AddEntityType(entityType2);
var key2A = entityType2.AddProperty("Id1", typeof(int));
var key2B = entityType2.AddProperty("Id2", typeof(string));
entityType2.SetKey(key2A, key2B);
var fk = entityType2.AddProperty("SomeEntityId", typeof(int));
entityType2.AddForeignKey(entityType.GetKey(), new[] { fk });
var justAProperty = entityType2.AddProperty("JustAProperty", typeof(int));
justAProperty.ValueGenerationOnSave = ValueGenerationOnSave.WhenInserting;
justAProperty.ValueGenerationOnAdd = ValueGenerationOnAdd.Client;
var entityType5 = new EntityType(typeof(SomeMoreDependentEntity));
model.AddEntityType(entityType5);
var key5 = entityType5.AddProperty("Id", typeof(int));
entityType5.SetKey(key5);
var fk5A = entityType5.AddProperty("Fk1", typeof(int));
var fk5B = entityType5.AddProperty("Fk2", typeof(string));
entityType5.AddForeignKey(entityType2.GetKey(), new[] { fk5A, fk5B });
return(model);
}
private void GenerateIndependentForeignKeyConstraint(
DbDatabaseMapping databaseMapping,
EntityType principalEntityType,
EntityType dependentEntityType,
EntityType dependentTable,
StorageAssociationSetMapping associationSetMapping,
StorageEndPropertyMapping associationEndMapping,
string name,
AssociationEndMember principalEnd,
bool isPrimaryKeyColumn = false)
{
DebugCheck.NotNull(databaseMapping);
DebugCheck.NotNull(principalEntityType);
DebugCheck.NotNull(dependentTable);
DebugCheck.NotNull(associationEndMapping);
DebugCheck.NotEmpty(name);
var principalTable
= GetEntityTypeMappingInHierarchy(databaseMapping, principalEntityType)
.MappingFragments
.Single()
.Table;
var foreignKeyConstraint
= new ForeignKeyBuilder(databaseMapping.Database, name)
{
PrincipalTable = principalTable,
DeleteAction = associationEndMapping.EndMember.DeleteBehavior != OperationAction.None
? associationEndMapping.EndMember.DeleteBehavior
: OperationAction.None
};
var principalNavigationProperty
= databaseMapping.Model.GetEntityTypes()
.SelectMany(e => e.DeclaredNavigationProperties)
.SingleOrDefault(n => n.ResultEnd == principalEnd);
dependentTable.AddForeignKey(foreignKeyConstraint);
foreignKeyConstraint.DependentColumns = GenerateIndependentForeignKeyColumns(
principalEntityType,
dependentEntityType,
associationSetMapping,
associationEndMapping,
dependentTable,
isPrimaryKeyColumn,
principalNavigationProperty);
}
private void CreateNavigationProperties(Microsoft.EntityFrameworkCore.ModelBuilder modelBuilder, String tableName)
{
foreach (String propertyName in MetadataProvider.GetNavigationProperties(tableName))
{
DynamicDependentPropertyInfo dependentInfo = MetadataProvider.GetDependentProperties(tableName, propertyName);
EntityType dependentEntityType = CreateEntityType(modelBuilder, MetadataProvider.GetTableName(dependentInfo.DependentEntityName));
EntityType principalEntityType = CreateEntityType(modelBuilder, MetadataProvider.GetTableName(dependentInfo.PrincipalEntityName));
var dependentProperties = new List <Property>();
foreach (String dependentPropertyName in dependentInfo.DependentPropertyNames)
{
dependentProperties.Add((Property)dependentEntityType.GetProperty(dependentPropertyName));
}
ForeignKey fkey = dependentEntityType.FindForeignKey(dependentProperties, principalEntityType.FindPrimaryKey(), principalEntityType);
if (fkey == null)
{
var principalProperties = new List <Property>();
foreach (String principalPropertyName in dependentInfo.PrincipalPropertyNames)
{
principalProperties.Add((Property)principalEntityType.GetProperty(principalPropertyName));
}
Key pkey = principalEntityType.FindKey(principalProperties);
if (pkey == null)
{
pkey = principalEntityType.AddKey(principalProperties);
}
fkey = dependentEntityType.AddForeignKey(dependentProperties, pkey, principalEntityType);
}
DynamicTypeDefinition dynamicTypeDefinition = TypeDefinitionManager.GetDynamicTypeDefinition(tableName);
if (dependentInfo.IsCollection)
{
Navigation navigation = fkey.HasPrincipalToDependent(propertyName);
navigation.SetField(dynamicTypeDefinition.GetCollectionFiledName(propertyName));
}
else
{
Navigation navigation = fkey.HasDependentToPrincipal(propertyName);
navigation.SetField(dynamicTypeDefinition.GetSingleFiledName(propertyName));
}
}
}
private static void MoveForeignKeyConstraint(
EntityType fromTable,
EntityType toTable,
ForeignKeyBuilder fk)
{
fromTable.RemoveForeignKey(fk);
if (fk.PrincipalTable == toTable && fk.DependentColumns.All <EdmProperty>((Func <EdmProperty, bool>)(c => c.IsPrimaryKeyColumn)))
{
return;
}
IList <EdmProperty> dependentColumns = ForeignKeyPrimitiveOperations.GetDependentColumns((IEnumerable <EdmProperty>)fk.DependentColumns.ToArray <EdmProperty>(), (IEnumerable <EdmProperty>)toTable.Properties);
if (ForeignKeyPrimitiveOperations.ContainsEquivalentForeignKey(toTable, fk.PrincipalTable, (IEnumerable <EdmProperty>)dependentColumns))
{
return;
}
toTable.AddForeignKey(fk);
fk.DependentColumns = (IEnumerable <EdmProperty>)dependentColumns;
}
private static Model BuildModel()
{
var model = new Model();
var entityType = new EntityType(typeof(Banana));
var property1 = entityType.AddProperty("P1", typeof(int));
var property2 = entityType.AddProperty("P2", typeof(string));
var property3 = entityType.AddProperty("P3", typeof(Random));
var property4 = entityType.AddProperty("P4", typeof(int));
var property5 = entityType.AddProperty("P5", typeof(string));
var property6 = entityType.AddProperty("P6", typeof(Random));
entityType.SetKey(property1, property2, property3);
entityType.AddForeignKey(entityType.GetKey(), property6, property4, property5);
model.AddEntityType(entityType);
return(model);
}
protected override Model BuildModel()
{
var model = new Model();
var entityType1 = new EntityType("SomeEntity");
model.AddEntityType(entityType1);
var key1 = entityType1.AddProperty("Id", typeof(int), shadowProperty: true, concurrencyToken: false);
key1.ValueGenerationOnSave = ValueGenerationOnSave.WhenInserting;
key1.ValueGenerationOnAdd = ValueGenerationOnAdd.Client;
entityType1.SetKey(key1);
entityType1.AddProperty("Name", typeof(string), shadowProperty: true, concurrencyToken: true);
var entityType2 = new EntityType("SomeDependentEntity");
model.AddEntityType(entityType2);
var key2a = entityType2.AddProperty("Id1", typeof(int), shadowProperty: true, concurrencyToken: false);
var key2b = entityType2.AddProperty("Id2", typeof(string), shadowProperty: true, concurrencyToken: false);
entityType2.SetKey(key2a, key2b);
var fk = entityType2.AddProperty("SomeEntityId", typeof(int), shadowProperty: true, concurrencyToken: false);
entityType2.AddForeignKey(entityType1.GetKey(), new[] { fk });
var justAProperty = entityType2.AddProperty("JustAProperty", typeof(int), shadowProperty: true, concurrencyToken: false);
justAProperty.ValueGenerationOnSave = ValueGenerationOnSave.WhenInserting;
justAProperty.ValueGenerationOnAdd = ValueGenerationOnAdd.Client;
var entityType3 = new EntityType(typeof(FullNotificationEntity));
model.AddEntityType(entityType3);
entityType3.SetKey(entityType3.AddProperty("Id", typeof(int), shadowProperty: true, concurrencyToken: false));
entityType3.AddProperty("Name", typeof(string), shadowProperty: true, concurrencyToken: true);
var entityType4 = new EntityType(typeof(ChangedOnlyEntity));
model.AddEntityType(entityType4);
entityType4.SetKey(entityType4.AddProperty("Id", typeof(int), shadowProperty: true, concurrencyToken: false));
entityType4.AddProperty("Name", typeof(string), shadowProperty: true, concurrencyToken: true);
var entityType5 = new EntityType("SomeMoreDependentEntity");
model.AddEntityType(entityType5);
var key5 = entityType5.AddProperty("Id", typeof(int), shadowProperty: true, concurrencyToken: false);
entityType5.SetKey(key5);
var fk5a = entityType5.AddProperty("Fk1", typeof(int), shadowProperty: true, concurrencyToken: false);
var fk5b = entityType5.AddProperty("Fk2", typeof(string), shadowProperty: true, concurrencyToken: false);
entityType5.AddForeignKey(entityType2.GetKey(), new[] { fk5a, fk5b });
return model;
}
private static Model BuildModel()
{
var model = new Model();
var entityType = new EntityType(typeof(Banana));
var pkProperty = entityType.AddProperty("Id", typeof(int));
var fkProperty = entityType.AddProperty("Fk", typeof(int));
entityType.SetKey(pkProperty);
var fk = entityType.AddForeignKey(entityType.GetKey(), fkProperty);
entityType.AddProperty("Name", typeof(string));
model.AddEntityType(entityType);
entityType.AddNavigation(new Navigation(fk, "LesserBananas", pointsToPrincipal: false));
entityType.AddNavigation(new Navigation(fk, "TopBanana", pointsToPrincipal: true));
return(model);
}
public void FK_back_pointer_is_fixed_up_as_FK_is_added()
{
var entityType = new EntityType(typeof(Customer));
var property = entityType.AddProperty(Customer.IdProperty);
entityType.SetKey(property);
var foreignKey
= entityType.AddForeignKey(entityType.GetKey(), property);
Assert.Same(entityType, foreignKey.EntityType);
Assert.Same(entityType, property.EntityType);
entityType.RemoveForeignKey(foreignKey);
// Currently property is not removed when FK is removed
Assert.Empty(entityType.ForeignKeys);
Assert.Same(property, entityType.Properties.Single());
Assert.Same(entityType, foreignKey.EntityType); // TODO: Throw here?
Assert.Same(entityType, property.EntityType);
}
private static IModel CreateModel()
{
var model = new Metadata.Model {
StorageName = "MyDatabase"
};
var dependentEntityType = new EntityType("Dependent")
{
StorageName = "dbo.MyTable0"
};
var principalEntityType = new EntityType("Principal")
{
StorageName = "dbo.MyTable1"
};
var dependentProperty = dependentEntityType.AddProperty("Id", typeof(int));
var principalProperty = principalEntityType.AddProperty("Id", typeof(int));
principalProperty.ValueGenerationStrategy = ValueGenerationStrategy.StoreIdentity;
model.AddEntityType(principalEntityType);
model.AddEntityType(dependentEntityType);
principalProperty.Annotations.Add(new Annotation(
MetadataExtensions.Annotations.StorageTypeName, "int"));
dependentProperty.Annotations.Add(new Annotation(
MetadataExtensions.Annotations.StorageTypeName, "int"));
dependentEntityType.SetKey(dependentProperty);
principalEntityType.SetKey(principalProperty);
dependentEntityType.GetKey().StorageName = "MyPK0";
principalEntityType.GetKey().StorageName = "MyPK1";
var foreignKey = dependentEntityType.AddForeignKey(principalEntityType.GetKey(), dependentProperty);
foreignKey.StorageName = "MyFK";
foreignKey.Annotations.Add(new Annotation(
MetadataExtensions.Annotations.CascadeDelete, "True"));
return(model);
}
public void Get_generation_property_returns_generation_property_from_foreign_key_chain()
{
var model = new Model();
var firstType = new EntityType("First", model);
var firstProperty = firstType.AddProperty("ID", typeof(int), true);
var firstKey = firstType.AddKey(firstProperty);
var secondType = new EntityType("Second", model);
var secondProperty = secondType.AddProperty("ID", typeof(int), true);
var secondKey = secondType.AddKey(secondProperty);
var secondForeignKey = secondType.AddForeignKey(secondProperty, firstKey, firstType);
var thirdType = new EntityType("Third", model);
var thirdProperty = thirdType.AddProperty("ID", typeof(int), true);
var thirdForeignKey = thirdType.AddForeignKey(thirdProperty, secondKey, secondType);
firstProperty.RequiresValueGenerator = true;
Assert.Equal(firstProperty, thirdProperty.GetGenerationProperty());
}
public void Get_generation_property_returns_generation_property_from_foreign_key_chain()
{
var model = new Model();
var firstType = new EntityType("First", model);
var firstProperty = firstType.AddProperty("ID", typeof(int), true);
var firstKey = firstType.AddKey(firstProperty);
var secondType = new EntityType("Second", model);
var secondProperty = secondType.AddProperty("ID", typeof(int), true);
var secondKey = secondType.AddKey(secondProperty);
var secondForeignKey = secondType.AddForeignKey(secondProperty, firstKey);
var thirdType = new EntityType("Third", model);
var thirdProperty = thirdType.AddProperty("ID", typeof(int), true);
var thirdForeignKey = thirdType.AddForeignKey(thirdProperty, secondKey);
firstProperty.GenerateValueOnAdd = true;
Assert.Equal(firstProperty, thirdProperty.GetGenerationProperty());
}
private static IModel CreateModelWithForeignKeys()
{
var model = new Model();
var houseType = new EntityType("Ho!use[]");
var houseId = houseType.AddProperty("Id", typeof(int));
houseType.SetKey(houseId);
model.AddEntityType(houseType);
var customerType = new EntityType(@"Customer");
var customerId = customerType.AddProperty("Id", typeof(int));
var customerFkProperty = customerType.AddProperty("HouseId", typeof(int));
customerFkProperty.SetColumnName(@"House[""Id]Column");
customerType.SetSchema("dbo");
customerType.SetTableName(@"Cus[""om.er]s");
customerType.SetKey(customerId);
customerType.GetKey().SetKeyName(@"My[""PK]");
customerType.GetKey().Annotations.Add(new Annotation(@"My""PK""Annotat!on", @"""Foo"""));
var customerFk = customerType.AddForeignKey(houseType.GetKey(), customerFkProperty);
customerFk.SetKeyName(@"My_[""FK]");
customerFk.Annotations.Add(new Annotation(@"My""FK""Annotation", @"""Bar"""));
model.AddEntityType(customerType);
var orderType = new EntityType(@"Order");
var orderId = orderType.AddProperty(@"OrderId", typeof(int));
var orderFK = orderType.AddProperty(@"CustomerId", typeof(int));
orderType.SetSchema("dbo");
orderType.SetKey(orderId);
orderType.SetTableName(@"Ord[""e.r]s");
orderType.AddForeignKey(customerType.GetKey(), orderFK);
orderType.Annotations.Add(new Annotation("Random annotation", "42"));
model.AddEntityType(orderType);
return(model);
}
public static void AddTypeConstraint(
EdmModel database,
EntityType entityType,
EntityType principalTable,
EntityType dependentTable,
bool isSplitting)
{
DebugCheck.NotNull(principalTable);
DebugCheck.NotNull(dependentTable);
DebugCheck.NotNull(entityType);
var foreignKeyConstraintMetadata
= new ForeignKeyBuilder(
database, String.Format(
CultureInfo.InvariantCulture,
"{0}_TypeConstraint_From_{1}_To_{2}",
entityType.Name,
principalTable.Name,
dependentTable.Name))
{
PrincipalTable = principalTable
};
dependentTable.AddForeignKey(foreignKeyConstraintMetadata);
if (isSplitting)
{
foreignKeyConstraintMetadata.SetIsSplitConstraint();
}
else
{
foreignKeyConstraintMetadata.SetIsTypeConstraint();
}
foreignKeyConstraintMetadata.DependentColumns = dependentTable.Properties.Where(c => c.IsPrimaryKeyColumn);
//If "DbStoreGeneratedPattern.Identity" was copied from the parent table, it should be removed
dependentTable.Properties.Where(c => c.IsPrimaryKeyColumn).Each(c => c.RemoveStoreGeneratedIdentityPattern());
}
private static Model BuildModel()
{
var model = new Model();
var entityType = new EntityType(typeof(Banana));
var property1 = entityType.AddProperty("P1", typeof(int));
var property2 = entityType.AddProperty("P2", typeof(string));
var property3 = entityType.AddProperty("P3", typeof(Random));
var property4 = entityType.AddProperty("P4", typeof(int));
var property5 = entityType.AddProperty("P5", typeof(string));
var property6 = entityType.AddProperty("P6", typeof(Random));
entityType.SetKey(property1, property2, property3);
entityType.AddForeignKey(entityType.GetKey(), property6, property4, property5);
model.AddEntityType(entityType);
return model;
}
public void Get_generation_property_returns_generation_property_from_foreign_key_graph_with_cycle()
{
var model = new Model();
var leafType = new EntityType("leaf", model);
var leafId1 = leafType.AddProperty("Id1", typeof(int), true);
var leafId2 = leafType.AddProperty("Id2", typeof(int), true);
var leafKey = leafType.AddKey(new[] { leafId1, leafId2 });
var firstType = new EntityType("First", model);
var firstId = firstType.AddProperty("Id", typeof(int), true);
var firstKey = firstType.AddKey(firstId);
var secondType = new EntityType("Second", model);
var secondId1 = secondType.AddProperty("Id1", typeof(int), true);
var secondId2 = secondType.AddProperty("Id2", typeof(int), true);
var secondKey = secondType.AddKey(secondId1);
var firstForeignKey = firstType.AddForeignKey(firstId, secondKey, secondType);
var secondForeignKey1 = secondType.AddForeignKey(secondId1, firstKey, firstType);
var secondForeignKey2 = secondType.AddForeignKey(new[] { secondId1, secondId2 }, leafKey, leafType);
leafId1.RequiresValueGenerator = true;
Assert.Equal(leafId1, secondId1.GetGenerationProperty());
}
private static IModel CreateModelWithForeignKeys()
{
var model = new Model();
var houseType = new EntityType("Ho!use[]");
var houseId = houseType.AddProperty("Id", typeof(int));
houseType.SetKey(houseId);
model.AddEntityType(houseType);
var customerType = new EntityType(@"Customer");
var customerId = customerType.AddProperty("Id", typeof(int));
var customerFkProperty = customerType.AddProperty("HouseId", typeof(int));
customerFkProperty.SetColumnName(@"House[""Id]Column");
customerType.SetSchema("dbo");
customerType.SetTableName(@"Cus[""om.er]s");
customerType.SetKey(customerId);
customerType.GetKey().SetKeyName(@"My[""PK]");
customerType.GetKey().Annotations.Add(new Annotation(@"My""PK""Annotat!on", @"""Foo"""));
var customerFk = customerType.AddForeignKey(houseType.GetKey(), customerFkProperty);
customerFk.SetKeyName(@"My_[""FK]");
customerFk.Annotations.Add(new Annotation(@"My""FK""Annotation", @"""Bar"""));
model.AddEntityType(customerType);
var orderType = new EntityType(@"Order");
var orderId = orderType.AddProperty(@"OrderId", typeof(int));
var orderFK = orderType.AddProperty(@"CustomerId", typeof(int));
orderType.SetSchema("dbo");
orderType.SetKey(orderId);
orderType.SetTableName(@"Ord[""e.r]s");
orderType.AddForeignKey(customerType.GetKey(), orderFK);
orderType.Annotations.Add(new Annotation("Random annotation", "42"));
model.AddEntityType(orderType);
return model;
}
public void Can_get_referencing_foreign_keys()
{
var model = new Model();
var entityType1 = new EntityType(typeof(Customer));
var entityType2 = new EntityType(typeof(Order));
var keyProperty = new Property("Id", typeof(Customer)) { EntityType = entityType1 };
var fkProperty = new Property("CustomerId", typeof(Order)) { EntityType = entityType2 };
var foreignKey = entityType2.AddForeignKey(new Key(new[] { keyProperty }), fkProperty);
model.AddEntityType(entityType1);
model.AddEntityType(entityType2);
var referencingForeignKeys = model.GetReferencingForeignKeys(entityType1);
Assert.Same(foreignKey, referencingForeignKeys.Single());
Assert.Same(foreignKey, entityType1.GetReferencingForeignKeys().Single());
}
private static IModel BuildModel()
{
var model = new Model();
var builder = new ModelBuilder(model);
builder.Annotation("ModelAnnotation1", "ModelValue1");
builder.Annotation("ModelAnnotation2", "ModelValue2");
var entityType1 = new EntityType(typeof(KoolEntity1));
var property = entityType1.AddProperty("Id1", typeof(int));
entityType1.SetKey(property);
entityType1.AddProperty("Id2", typeof(Guid));
entityType1.AddProperty("KoolEntity2Id", typeof(int));
model.AddEntityType(entityType1);
var entityType2 = new EntityType(typeof(KoolEntity2));
entityType2.AddProperty("KoolEntity1Id1", typeof(int));
entityType2.AddProperty("KoolEntity1Id2", typeof(Guid));
entityType2.AddProperty("KoolEntity3Id", typeof(int));
model.AddEntityType(entityType2);
var entityType3 = new EntityType(typeof(KoolEntity3));
entityType3.AddProperty("KoolEntity4Id", typeof(int));
model.AddEntityType(entityType3);
var entityType4 = new EntityType(typeof(KoolEntity4));
model.AddEntityType(entityType4);
var entityType5 = new EntityType(typeof(KoolEntity5));
model.AddEntityType(entityType5);
var entityType6 = new EntityType(typeof(KoolEntity6));
entityType6.AddProperty("Kool5Id", typeof(int));
model.AddEntityType(entityType6);
for (var i = 7; i <= 20; i++)
{
var type = Type.GetType("Microsoft.Data.Entity.FunctionalTests.Metadata.KoolEntity" + i);
Assert.NotNull(type);
model.AddEntityType(new EntityType(type));
}
for (var i = 2; i <= 20; i++)
{
var type = Type.GetType("Microsoft.Data.Entity.FunctionalTests.Metadata.KoolEntity" + i);
var entityType = model.GetEntityType(type);
var id = entityType.AddProperty(entityType.Type.GetProperty("Id"));
entityType.SetKey(id);
}
for (var i = 1; i <= 20; i++)
{
var type = Type.GetType("Microsoft.Data.Entity.FunctionalTests.Metadata.KoolEntity" + i);
var entityType = model.GetEntityType(type);
entityType.Annotations.Add(new Annotation("Annotation1", "Value1"));
entityType.Annotations.Add(new Annotation("Annotation2", "Value2"));
var foo = entityType.AddProperty(entityType.Type.GetProperty("Foo" + i));
foo.Annotations.Add(new Annotation("Foo" + i + "Annotation1", "Foo" + i + "Value1"));
foo.Annotations.Add(new Annotation("Foo" + i + "Annotation2", "Foo" + i + "Value2"));
var goo = entityType.AddProperty(entityType.Type.GetProperty("Goo" + i));
}
var fk11 = entityType1.AddForeignKey(entityType2.GetKey(), new[] { entityType1.GetProperty("KoolEntity2Id") });
var fk21 = entityType2.AddForeignKey(entityType1.GetKey(), new[] { entityType2.GetProperty("KoolEntity1Id1") });
var fk22 = entityType2.AddForeignKey(entityType3.GetKey(), new[] { entityType2.GetProperty("KoolEntity3Id") });
var fk31 = entityType3.AddForeignKey(entityType4.GetKey(), new[] { entityType3.GetProperty("KoolEntity4Id") });
var fk61 = entityType6.AddForeignKey(entityType5.GetKey(), new[] { entityType6.GetProperty("Kool5Id") });
entityType1.AddNavigation(new Navigation(fk11, "NavTo2", pointsToPrincipal: true));
entityType1.AddNavigation(new Navigation(fk21, "NavTo2s", pointsToPrincipal: false));
entityType2.AddNavigation(new Navigation(fk21, "NavTo1", pointsToPrincipal: true));
entityType2.AddNavigation(new Navigation(fk11, "NavTo1s", pointsToPrincipal: false));
entityType2.AddNavigation(new Navigation(fk22, "NavTo3", pointsToPrincipal: true));
entityType3.AddNavigation(new Navigation(fk22, "NavTo2s", pointsToPrincipal: false));
entityType3.AddNavigation(new Navigation(fk31, "NavTo4", pointsToPrincipal: true));
entityType4.AddNavigation(new Navigation(fk31, "NavTo3s", pointsToPrincipal: false));
entityType5.AddNavigation(new Navigation(fk61, "Kool6s", pointsToPrincipal: false));
entityType6.AddNavigation(new Navigation(fk61, "Kool5", pointsToPrincipal: true));
return model;
}
public void FK_back_pointer_is_fixed_up_as_FK_is_added()
{
var entityType = new EntityType(typeof(Customer));
var property = entityType.AddProperty(Customer.IdProperty);
entityType.SetKey(property);
var foreignKey
= entityType.AddForeignKey(entityType.GetKey(), property);
Assert.Same(entityType, foreignKey.EntityType);
Assert.Same(entityType, property.EntityType);
entityType.RemoveForeignKey(foreignKey);
// Currently property is not removed when FK is removed
Assert.Empty(entityType.ForeignKeys);
Assert.Same(property, entityType.Properties.Single());
Assert.Same(entityType, foreignKey.EntityType); // TODO: Throw here?
Assert.Same(entityType, property.EntityType);
}
public void Foreign_keys_are_ordered_by_property_count_then_property_names()
{
var customerType = new EntityType(typeof(Customer), new Model());
var idProperty = customerType.GetOrAddProperty(Customer.IdProperty);
var nameProperty = customerType.GetOrAddProperty(Customer.NameProperty);
var customerKey = customerType.GetOrAddKey(idProperty);
var otherCustomerKey = customerType.GetOrAddKey(new[] { idProperty, nameProperty });
var orderType = new EntityType(typeof(Order), new Model());
var customerFk1 = orderType.GetOrAddProperty(Order.CustomerIdProperty);
var customerFk2 = orderType.GetOrAddProperty("IdAgain", typeof(int), shadowProperty: true);
var customerFk3A = orderType.GetOrAddProperty("OtherId1", typeof(int), shadowProperty: true);
var customerFk3B = orderType.GetOrAddProperty("OtherId2", typeof(string), shadowProperty: true);
var customerFk4B = orderType.GetOrAddProperty("OtherId3", typeof(string), shadowProperty: true);
var fk2 = orderType.AddForeignKey(customerFk2, customerKey);
var fk4 = orderType.AddForeignKey(new[] { customerFk3A, customerFk4B }, otherCustomerKey);
var fk3 = orderType.AddForeignKey(new[] { customerFk3A, customerFk3B }, otherCustomerKey);
var fk1 = orderType.AddForeignKey(customerFk1, customerKey);
Assert.True(new[] { fk1, fk2, fk3, fk4 }.SequenceEqual(orderType.ForeignKeys));
}
public void Navigations_are_ordered_by_name()
{
var customerType = new EntityType(typeof(Customer), new Model());
var customerKey = customerType.GetOrAddKey(customerType.GetOrAddProperty(Customer.IdProperty));
var orderType = new EntityType(typeof(Order), new Model());
var customerForeignKeyProperty = orderType.AddProperty(Order.CustomerIdProperty);
var customerForeignKey = orderType.AddForeignKey(customerForeignKeyProperty, customerKey);
var specialOrderType = new EntityType(typeof(SpecialOrder), new Model());
var specialCustomerForeignKeyProperty = specialOrderType.AddProperty(Order.CustomerIdProperty);
var specialCustomerForeignKey = specialOrderType.AddForeignKey(specialCustomerForeignKeyProperty, customerKey);
var navigation2 = customerType.AddNavigation("Orders", customerForeignKey, pointsToPrincipal: false);
var navigation1 = customerType.AddNavigation("DerivedOrders", specialCustomerForeignKey, pointsToPrincipal: false);
Assert.True(new[] { navigation1, navigation2 }.SequenceEqual(customerType.Navigations));
}
public void Diff_finds_created_table()
{
var sourceModel = CreateModel();
var targetModel = CreateModel();
var principalEntityType = targetModel.GetEntityType("Principal");
var dependentEntityType = new EntityType("NewDependent");
dependentEntityType.SetTableName("MyNewTable");
dependentEntityType.SetSchema("dbo");
var dependentProperty = dependentEntityType.AddProperty("Id", typeof(int));
targetModel.AddEntityType(dependentEntityType);
dependentProperty.Annotations.Add(new Annotation(
MetadataExtensions.Annotations.StorageTypeName, "int"));
dependentEntityType.SetKey(dependentProperty);
dependentEntityType.GetKey().SetKeyName("MyNewPK");
var foreignKey = dependentEntityType.AddForeignKey(principalEntityType.GetKey(), dependentProperty);
foreignKey.SetKeyName("MyNewFK");
foreignKey.Annotations.Add(new Annotation(
MetadataExtensions.Annotations.CascadeDelete, "True"));
var operations = new ModelDiffer(new DatabaseBuilder()).Diff(sourceModel, targetModel);
Assert.Equal(2, operations.Count);
Assert.IsType<CreateTableOperation>(operations[0]);
Assert.IsType<AddForeignKeyOperation>(operations[1]);
var createTableOperation = (CreateTableOperation)operations[0];
Assert.Equal("dbo.MyNewTable", createTableOperation.Table.Name);
Assert.Equal(1, createTableOperation.Table.Columns.Count);
Assert.Equal("Id", createTableOperation.Table.Columns[0].Name);
Assert.Equal(typeof(int), createTableOperation.Table.Columns[0].ClrType);
Assert.NotNull(createTableOperation.Table.PrimaryKey);
Assert.Equal("MyNewPK", createTableOperation.Table.PrimaryKey.Name);
Assert.Equal(1, createTableOperation.Table.ForeignKeys.Count);
Assert.Equal("MyNewFK", createTableOperation.Table.ForeignKeys[0].Name);
Assert.True(createTableOperation.Table.ForeignKeys[0].CascadeDelete);
var addForeignKeyOperation = (AddForeignKeyOperation)operations[1];
Assert.Equal("MyNewFK", addForeignKeyOperation.ForeignKeyName);
Assert.Equal("dbo.MyNewTable", addForeignKeyOperation.TableName);
Assert.Equal("dbo.MyTable1", addForeignKeyOperation.ReferencedTableName);
Assert.Equal(new[] { "Id" }, addForeignKeyOperation.ColumnNames);
Assert.Equal(new[] { "Id" }, addForeignKeyOperation.ReferencedColumnNames);
Assert.True(addForeignKeyOperation.CascadeDelete);
}
public void Can_remove_foreign_keys()
{
var customerType = new EntityType(typeof(Customer), new Model());
var customerKey = customerType.GetOrAddKey(customerType.GetOrAddProperty(Customer.IdProperty));
var orderType = new EntityType(typeof(Order), new Model());
var customerFk1 = orderType.GetOrAddProperty(Order.CustomerIdProperty);
var customerFk2 = orderType.GetOrAddProperty("IdAgain", typeof(int), shadowProperty: true);
Assert.Equal(
Strings.ForeignKeyNotFound("{'" + Order.CustomerIdProperty.Name + "'}", typeof(Order).FullName),
Assert.Throws<ModelItemNotFoundException>(() => orderType.GetForeignKey(customerFk1)).Message);
Assert.Null(orderType.RemoveForeignKey(new ForeignKey(new[] { customerFk2 }, customerKey)));
var fk1 = orderType.AddForeignKey(customerFk1, customerKey);
var fk2 = orderType.AddForeignKey(customerFk2, customerKey);
Assert.Equal(new[] { fk1, fk2 }, orderType.ForeignKeys.ToArray());
Assert.Same(fk1, orderType.RemoveForeignKey(fk1));
Assert.Null(orderType.RemoveForeignKey(fk1));
Assert.Equal(
Strings.ForeignKeyNotFound("{'" + Order.CustomerIdProperty.Name + "'}", typeof(Order).FullName),
Assert.Throws<ModelItemNotFoundException>(() => orderType.GetForeignKey(customerFk1)).Message);
Assert.Equal(new[] { fk2 }, orderType.ForeignKeys.ToArray());
Assert.Same(fk2, orderType.RemoveForeignKey(new ForeignKey(new[] { customerFk2 }, customerKey)));
Assert.Empty(orderType.ForeignKeys);
}
public void Can_create_self_referencing_navigations()
{
var entityType = new EntityType(typeof(SelfRef), new Model());
var fkProperty = entityType.AddProperty("ForeignKey", typeof(int));
var principalEntityType = entityType;
var principalKeyProperty = principalEntityType.AddProperty("Id", typeof(int));
var referencedKey = principalEntityType.SetPrimaryKey(principalKeyProperty);
var fk = entityType.AddForeignKey(fkProperty, referencedKey);
fk.IsUnique = true;
var navigationToDependent = principalEntityType.AddNavigation("SelfRef1", fk, pointsToPrincipal: false);
var navigationToPrincipal = principalEntityType.AddNavigation("SelfRef2", fk, pointsToPrincipal: true);
Assert.Same(fk.GetNavigationToDependent(), navigationToDependent);
Assert.Same(fk.GetNavigationToPrincipal(), navigationToPrincipal);
}
private static Model BuildModel()
{
var model = new Model();
var entityType = new EntityType(typeof(Banana));
var property1 = entityType.AddProperty("P1", typeof(int));
var property2 = entityType.AddProperty("P2", typeof(string));
entityType.SetKey(property1);
entityType.AddForeignKey(entityType.GetKey(), property2);
model.AddEntityType(entityType);
return model;
}
private static Model BuildModel()
{
var model = new Model();
var entityType = new EntityType(typeof(Banana));
var pkProperty = entityType.AddProperty("Id", typeof(int));
var fkProperty = entityType.AddProperty("Fk", typeof(int));
entityType.SetKey(pkProperty);
var fk = entityType.AddForeignKey(entityType.GetKey(), fkProperty);
entityType.AddProperty("Name", typeof(string));
model.AddEntityType(entityType);
entityType.AddNavigation(new Navigation(fk, "LesserBananas", pointsToPrincipal: false));
entityType.AddNavigation(new Navigation(fk, "TopBanana", pointsToPrincipal: true));
return model;
}
protected ForeignKey CreateForeignKey(EntityType dependEntityType, IReadOnlyList<Property> dependentProperties, Key principalKey)
{
var foreignKey = dependEntityType.AddForeignKey(dependentProperties, principalKey, principalKey.DeclaringEntityType);
foreignKey.IsUnique = true;
foreignKey.IsRequired = false;
foreach (var property in dependentProperties)
{
property.RequiresValueGenerator = false;
}
return foreignKey;
}
public void Can_get_or_add_a_foreign_key()
{
var customerType = new EntityType(typeof(Customer), new Model());
var idProperty = customerType.GetOrAddProperty(Customer.IdProperty);
var customerKey = customerType.GetOrAddKey(idProperty);
var orderType = new EntityType(typeof(Order), new Model());
var customerFk1 = orderType.GetOrAddProperty(Order.CustomerIdProperty);
var customerFk2 = orderType.GetOrAddProperty("IdAgain", typeof(int), shadowProperty: true);
var fk1 = orderType.AddForeignKey(customerFk1, customerKey);
var fk2 = orderType.GetOrAddForeignKey(customerFk2, customerKey);
Assert.NotNull(fk2);
Assert.NotEqual(fk1, fk2);
Assert.Same(fk2, orderType.GetForeignKey(customerFk2));
Assert.Same(fk2, orderType.FindForeignKey(customerFk2));
Assert.Equal(new[] { fk1, fk2 }, orderType.ForeignKeys.ToArray());
Assert.Same(fk2, orderType.GetOrAddForeignKey(customerFk2, customerKey));
Assert.Equal(new[] { fk1, fk2 }, orderType.ForeignKeys.ToArray());
}
public void Diff_finds_dropped_table()
{
var sourceModel = CreateModel();
var targetModel = CreateModel();
var principalEntityType = targetModel.GetEntityType("Principal");
var dependentEntityType = new EntityType("OldDependent");
dependentEntityType.SetTableName("MyOldTable");
dependentEntityType.SetSchema("dbo");
var dependentProperty = dependentEntityType.AddProperty("Id", typeof(int));
sourceModel.AddEntityType(dependentEntityType);
dependentProperty.Annotations.Add(new Annotation(
MetadataExtensions.Annotations.StorageTypeName, "int"));
dependentEntityType.SetKey(dependentProperty);
dependentEntityType.GetKey().SetKeyName("MyOldPK");
var foreignKey = dependentEntityType.AddForeignKey(principalEntityType.GetKey(), dependentProperty);
foreignKey.SetKeyName("MyOldFK");
foreignKey.Annotations.Add(new Annotation(
MetadataExtensions.Annotations.CascadeDelete, "True"));
var operations = new ModelDiffer(new DatabaseBuilder()).Diff(sourceModel, targetModel);
Assert.Equal(1, operations.Count);
Assert.IsType<DropTableOperation>(operations[0]);
var dropTableOperation = (DropTableOperation)operations[0];
Assert.Equal("dbo.MyOldTable", dropTableOperation.TableName);
}
public void FK_properties_are_marked_as_requiring_original_values()
{
var entityType = new EntityType(typeof(FullNotificationEntity));
entityType.SetKey(entityType.AddProperty("Id", typeof(int)));
Assert.Equal(-1, entityType.GetProperty("Id").OriginalValueIndex);
entityType.AddForeignKey(entityType.GetKey(), new[] { entityType.AddProperty("Id", typeof(int)) });
Assert.Equal(0, entityType.GetProperty("Id").OriginalValueIndex);
}
public void Adding_a_foreign_key_throws_if_properties_from_different_type()
{
var entityType1 = new EntityType(typeof(Customer), new Model());
var entityType2 = new EntityType(typeof(Order), new Model());
var idProperty = entityType2.GetOrAddProperty(Customer.IdProperty);
Assert.Equal(
Strings.ForeignKeyPropertiesWrongEntity("{'" + Customer.IdProperty.Name + "'}", typeof(Customer).FullName),
Assert.Throws<ArgumentException>(() => entityType1.AddForeignKey(new[] { idProperty }, entityType2.GetOrAddKey(idProperty))).Message);
}
private static IModel CreateModel()
{
var model = new Metadata.Model { StorageName = "MyDatabase" };
var dependentEntityType = new EntityType("Dependent");
dependentEntityType.SetSchema("dbo");
dependentEntityType.SetTableName("MyTable0");
var principalEntityType = new EntityType("Principal");
principalEntityType.SetSchema("dbo");
principalEntityType.SetTableName("MyTable1");
var dependentProperty = dependentEntityType.AddProperty("Id", typeof(int));
var principalProperty = principalEntityType.AddProperty("Id", typeof(int));
principalProperty.ValueGenerationOnSave = ValueGenerationOnSave.WhenInserting;
model.AddEntityType(principalEntityType);
model.AddEntityType(dependentEntityType);
principalProperty.Annotations.Add(new Annotation(
MetadataExtensions.Annotations.StorageTypeName, "int"));
dependentProperty.Annotations.Add(new Annotation(
MetadataExtensions.Annotations.StorageTypeName, "int"));
dependentEntityType.SetKey(dependentProperty);
principalEntityType.SetKey(principalProperty);
dependentEntityType.GetKey().SetKeyName("MyPK0");
principalEntityType.GetKey().SetKeyName("MyPK1");
var foreignKey = dependentEntityType.AddForeignKey(principalEntityType.GetKey(), dependentProperty);
foreignKey.SetKeyName("MyFK");
foreignKey.Annotations.Add(new Annotation(
MetadataExtensions.Annotations.CascadeDelete, "True"));
var index = dependentEntityType.AddIndex(dependentProperty);
index.SetIndexName("MyIndex");
index.IsUnique = true;
return model;
}
public void Adding_a_foreign_key_throws_if_duplicate()
{
var customerType = new EntityType(typeof(Customer), new Model());
var customerKey = customerType.GetOrAddKey(customerType.GetOrAddProperty(Customer.IdProperty));
var orderType = new EntityType(typeof(Order), new Model());
var customerFk1 = orderType.GetOrAddProperty(Order.CustomerIdProperty);
orderType.AddForeignKey(customerFk1, customerKey);
Assert.Equal(
Strings.DuplicateForeignKey("{'" + Order.CustomerIdProperty.Name + "'}", typeof(Order).FullName),
Assert.Throws<InvalidOperationException>(() => orderType.AddForeignKey(customerFk1, customerKey)).Message);
}
public void Add_foreign_key()
{
var entityType = new EntityType(typeof(Order));
entityType.SetKey(entityType.AddProperty(Order.IdProperty));
var foreignKey
= entityType.AddForeignKey(
entityType.GetKey(),
new[] { entityType.AddProperty(Order.CustomerUniqueProperty) });
Assert.True(entityType.ForeignKeys.Contains(foreignKey));
}
public void Setting_foreign_key_properties_should_update_existing_properties()
{
var entityType = new EntityType(typeof(Order));
entityType.SetKey(entityType.AddProperty(Order.CustomerIdProperty));
var newIdProperty = entityType.AddProperty(Order.CustomerIdProperty);
var property2 = entityType.AddProperty(Order.CustomerUniqueProperty);
entityType.AddForeignKey(entityType.GetKey(), new[] { newIdProperty, property2 });
Assert.Equal(new[] { newIdProperty, property2 }, entityType.Properties.ToArray());
}