private void GenerateIndependentAssociationType(
AssociationType associationType,
DbDatabaseMapping databaseMapping)
{
AssociationEndMember principalEnd;
AssociationEndMember dependentEnd;
if (!associationType.TryGuessPrincipalAndDependentEnds(out principalEnd, out dependentEnd))
{
if (!associationType.IsPrincipalConfigured())
{
throw Error.UnableToDeterminePrincipal((object)EntityTypeExtensions.GetClrType(associationType.SourceEnd.GetEntityType()), (object)EntityTypeExtensions.GetClrType(associationType.TargetEnd.GetEntityType()));
}
principalEnd = associationType.SourceEnd;
dependentEnd = associationType.TargetEnd;
}
EntityTypeMapping mappingInHierarchy = StructuralTypeMappingGenerator.GetEntityTypeMappingInHierarchy(databaseMapping, dependentEnd.GetEntityType());
EntityType table = mappingInHierarchy.MappingFragments.First <MappingFragment>().Table;
AssociationSetMapping associationSetMapping = AssociationTypeMappingGenerator.GenerateAssociationSetMapping(associationType, databaseMapping, principalEnd, dependentEnd, table);
this.GenerateIndependentForeignKeyConstraint(databaseMapping, principalEnd.GetEntityType(), dependentEnd.GetEntityType(), table, associationSetMapping, associationSetMapping.SourceEndMapping, associationType.Name, principalEnd, false);
foreach (EdmProperty keyProperty in dependentEnd.GetEntityType().KeyProperties())
{
associationSetMapping.TargetEndMapping.AddPropertyMapping(new ScalarPropertyMapping(keyProperty, mappingInHierarchy.GetPropertyMapping(keyProperty).ColumnProperty));
}
}
private static IEnumerable <Tuple <ModificationFunctionMemberPath, EdmProperty> > GetIndependentFkColumns(
EntityType entityType,
DbDatabaseMapping databaseMapping)
{
foreach (AssociationSetMapping associationSetMapping in databaseMapping.GetAssociationSetMappings())
{
AssociationType associationType = associationSetMapping.AssociationSet.ElementType;
if (!associationType.IsManyToMany())
{
AssociationEndMember _;
AssociationEndMember dependentEnd;
if (!associationType.TryGuessPrincipalAndDependentEnds(out _, out dependentEnd))
{
dependentEnd = associationType.TargetEnd;
}
EntityType dependentEntityType = dependentEnd.GetEntityType();
if (dependentEntityType == entityType || ModificationFunctionMappingGenerator.GetParents(entityType).Contains <EntityType>(dependentEntityType))
{
EndPropertyMapping endPropertyMapping = associationSetMapping.TargetEndMapping.AssociationEnd != dependentEnd ? associationSetMapping.TargetEndMapping : associationSetMapping.SourceEndMapping;
foreach (ScalarPropertyMapping propertyMapping in endPropertyMapping.PropertyMappings)
{
yield return(Tuple.Create <ModificationFunctionMemberPath, EdmProperty>(new ModificationFunctionMemberPath((IEnumerable <EdmMember>) new EdmMember[2]
{
(EdmMember)propertyMapping.Property,
(EdmMember)dependentEnd
}, associationSetMapping.AssociationSet), propertyMapping.Column));
}
}
}
}
}
private static void UpdatePrincipalTables(
DbDatabaseMapping databaseMapping,
EntityType toTable,
bool removeFks,
AssociationType associationType,
EntityType et)
{
List <AssociationEndMember> associationEndMemberList = new List <AssociationEndMember>();
AssociationEndMember principalEnd;
AssociationEndMember dependentEnd;
if (associationType.TryGuessPrincipalAndDependentEnds(out principalEnd, out dependentEnd))
{
associationEndMemberList.Add(principalEnd);
}
else if (associationType.SourceEnd.RelationshipMultiplicity == RelationshipMultiplicity.Many && associationType.TargetEnd.RelationshipMultiplicity == RelationshipMultiplicity.Many)
{
associationEndMemberList.Add(associationType.SourceEnd);
associationEndMemberList.Add(associationType.TargetEnd);
}
else
{
associationEndMemberList.Add(associationType.SourceEnd);
}
foreach (AssociationEndMember associationEnd in associationEndMemberList)
{
if (associationEnd.GetEntityType() == et)
{
IEnumerable <KeyValuePair <EntityType, IEnumerable <EdmProperty> > > keyValuePairs;
if (associationType.Constraint != null)
{
EntityType entityType = associationType.GetOtherEnd(associationEnd).GetEntityType();
keyValuePairs = databaseMapping.Model.GetSelfAndAllDerivedTypes(entityType).Select <EntityType, EntityTypeMapping>((Func <EntityType, EntityTypeMapping>)(t => databaseMapping.GetEntityTypeMapping(t))).Where <EntityTypeMapping>((Func <EntityTypeMapping, bool>)(dm => dm != null)).SelectMany <EntityTypeMapping, MappingFragment>((Func <EntityTypeMapping, IEnumerable <MappingFragment> >)(dm => dm.MappingFragments.Where <MappingFragment>((Func <MappingFragment, bool>)(tmf => associationType.Constraint.ToProperties.All <EdmProperty>((Func <EdmProperty, bool>)(p => tmf.ColumnMappings.Any <ColumnMappingBuilder>((Func <ColumnMappingBuilder, bool>)(pm => pm.PropertyPath.First <EdmProperty>() == p)))))))).Distinct <MappingFragment>((Func <MappingFragment, MappingFragment, bool>)((f1, f2) => f1.Table == f2.Table)).Select <MappingFragment, KeyValuePair <EntityType, IEnumerable <EdmProperty> > >((Func <MappingFragment, KeyValuePair <EntityType, IEnumerable <EdmProperty> > >)(df => new KeyValuePair <EntityType, IEnumerable <EdmProperty> >(df.Table, df.ColumnMappings.Where <ColumnMappingBuilder>((Func <ColumnMappingBuilder, bool>)(pm => associationType.Constraint.ToProperties.Contains(pm.PropertyPath.First <EdmProperty>()))).Select <ColumnMappingBuilder, EdmProperty>((Func <ColumnMappingBuilder, EdmProperty>)(pm => pm.ColumnProperty)))));
}
else
{
AssociationSetMapping associationSetMapping = databaseMapping.EntityContainerMappings.Single <EntityContainerMapping>().AssociationSetMappings.Single <AssociationSetMapping>((Func <AssociationSetMapping, bool>)(asm => asm.AssociationSet.ElementType == associationType));
keyValuePairs = (IEnumerable <KeyValuePair <EntityType, IEnumerable <EdmProperty> > >) new KeyValuePair <EntityType, IEnumerable <EdmProperty> >[1]
{
new KeyValuePair <EntityType, IEnumerable <EdmProperty> >(associationSetMapping.Table, (associationSetMapping.SourceEndMapping.AssociationEnd == associationEnd ? (IEnumerable <ScalarPropertyMapping>)associationSetMapping.SourceEndMapping.PropertyMappings : (IEnumerable <ScalarPropertyMapping>)associationSetMapping.TargetEndMapping.PropertyMappings).Select <ScalarPropertyMapping, EdmProperty>((Func <ScalarPropertyMapping, EdmProperty>)(pm => pm.Column)))
};
}
foreach (KeyValuePair <EntityType, IEnumerable <EdmProperty> > keyValuePair in keyValuePairs)
{
KeyValuePair <EntityType, IEnumerable <EdmProperty> > tableInfo = keyValuePair;
foreach (ForeignKeyBuilder foreignKeyBuilder in tableInfo.Key.ForeignKeyBuilders.Where <ForeignKeyBuilder>((Func <ForeignKeyBuilder, bool>)(fk => fk.DependentColumns.SequenceEqual <EdmProperty>(tableInfo.Value))).ToArray <ForeignKeyBuilder>())
{
if (removeFks)
{
tableInfo.Key.RemoveForeignKey(foreignKeyBuilder);
}
else if (foreignKeyBuilder.GetAssociationType() == null || foreignKeyBuilder.GetAssociationType() == associationType)
{
foreignKeyBuilder.PrincipalTable = toTable;
}
}
}
}
}
}
private void ConfigureDependentBehavior(
AssociationType associationType, EdmModel model, EntityTypeConfiguration entityTypeConfiguration)
{
DebugCheck.NotNull(associationType);
DebugCheck.NotNull(model);
DebugCheck.NotNull(entityTypeConfiguration);
AssociationEndMember principalEnd;
AssociationEndMember dependentEnd;
if (!associationType.TryGuessPrincipalAndDependentEnds(out principalEnd, out dependentEnd))
{
if (IsNavigationPropertyDeclaringTypePrincipal.HasValue)
{
associationType.MarkPrincipalConfigured();
var navProp = model.EntityTypes
.SelectMany(et => et.DeclaredNavigationProperties)
.Single(
np => np.RelationshipType.Equals(associationType) && // CodePlex 546
np.GetClrPropertyInfo().IsSameAs(NavigationProperty));
principalEnd = IsNavigationPropertyDeclaringTypePrincipal.Value
? associationType.GetOtherEnd(navProp.ResultEnd)
: navProp.ResultEnd;
dependentEnd = associationType.GetOtherEnd(principalEnd);
if (associationType.SourceEnd != principalEnd)
{
// need to move around source to be principal, target to be dependent so Edm services will use the correct
// principal and dependent ends. The Edm default Db + mapping service tries to guess principal/dependent
// based on multiplicities, but if it can't figure it out, it will use source as principal and target as dependent
associationType.SourceEnd = principalEnd;
associationType.TargetEnd = dependentEnd;
var associationSet
= model.Containers
.SelectMany(ct => ct.AssociationSets)
.Single(aset => aset.ElementType == associationType);
var sourceSet = associationSet.SourceSet;
associationSet.SourceSet = associationSet.TargetSet;
associationSet.TargetSet = sourceSet;
}
}
if (principalEnd == null)
{
dependentEnd = associationType.TargetEnd;
}
}
ConfigureConstraint(associationType, dependentEnd, entityTypeConfiguration);
ConfigureDeleteAction(associationType.GetOtherEnd(dependentEnd));
}
private void GenerateIndependentAssociationType(
AssociationType associationType, DbDatabaseMapping databaseMapping)
{
DebugCheck.NotNull(associationType);
DebugCheck.NotNull(databaseMapping);
AssociationEndMember principalEnd, dependentEnd;
if (!associationType.TryGuessPrincipalAndDependentEnds(out principalEnd, out dependentEnd))
{
if (!associationType.IsPrincipalConfigured())
{
throw Error.UnableToDeterminePrincipal(
associationType.SourceEnd.GetEntityType().GetClrType(),
associationType.TargetEnd.GetEntityType().GetClrType());
}
principalEnd = associationType.SourceEnd;
dependentEnd = associationType.TargetEnd;
}
var dependentEntityTypeMapping = GetEntityTypeMappingInHierarchy(databaseMapping, dependentEnd.GetEntityType());
var dependentTable = dependentEntityTypeMapping
.MappingFragments
.First()
.Table;
var associationSetMapping
= GenerateAssociationSetMapping(
associationType, databaseMapping, principalEnd, dependentEnd, dependentTable);
GenerateIndependentForeignKeyConstraint(
databaseMapping,
principalEnd.GetEntityType(),
dependentEnd.GetEntityType(),
dependentTable,
associationSetMapping,
associationSetMapping.SourceEndMapping,
associationType.Name,
principalEnd);
foreach (var property in dependentEnd.GetEntityType().KeyProperties())
{
associationSetMapping.TargetEndMapping
.AddProperty(
new StorageScalarPropertyMapping(
property,
dependentEntityTypeMapping.GetPropertyMapping(property).ColumnProperty));
}
}
public void TryGuessPrincipalAndDependentEnds_should_return_correct_ends_for_optional_to_required()
{
var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace);
associationType.SourceEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace));
associationType.TargetEnd = new AssociationEndMember("T", new EntityType("E", "N", DataSpace.CSpace));
associationType.SourceEnd.RelationshipMultiplicity = RelationshipMultiplicity.ZeroOrOne;
associationType.TargetEnd.RelationshipMultiplicity = RelationshipMultiplicity.One;
AssociationEndMember principalEnd, dependentEnd;
associationType.TryGuessPrincipalAndDependentEnds(out principalEnd, out dependentEnd);
Assert.Same(associationType.TargetEnd, principalEnd);
Assert.Same(associationType.SourceEnd, dependentEnd);
}
public void TryGuessPrincipalAndDependentEnds_should_return_correct_ends_for_optional_to_required()
{
var associationType = new AssociationType();
associationType.SourceEnd = new AssociationEndMember("S", new EntityType());
associationType.TargetEnd = new AssociationEndMember("T", new EntityType());
associationType.SourceEnd.RelationshipMultiplicity = RelationshipMultiplicity.ZeroOrOne;
associationType.TargetEnd.RelationshipMultiplicity = RelationshipMultiplicity.One;
AssociationEndMember principalEnd, dependentEnd;
associationType.TryGuessPrincipalAndDependentEnds(out principalEnd, out dependentEnd);
Assert.Same(associationType.TargetEnd, principalEnd);
Assert.Same(associationType.SourceEnd, dependentEnd);
}
private void ConfigureDependentBehavior(
AssociationType associationType,
EdmModel model,
EntityTypeConfiguration entityTypeConfiguration)
{
AssociationEndMember principalEnd;
AssociationEndMember dependentEnd;
if (!associationType.TryGuessPrincipalAndDependentEnds(out principalEnd, out dependentEnd))
{
if (this.IsNavigationPropertyDeclaringTypePrincipal.HasValue)
{
associationType.MarkPrincipalConfigured();
System.Data.Entity.Core.Metadata.Edm.NavigationProperty navigationProperty = model.EntityTypes.SelectMany <EntityType, System.Data.Entity.Core.Metadata.Edm.NavigationProperty>((Func <EntityType, IEnumerable <System.Data.Entity.Core.Metadata.Edm.NavigationProperty> >)(et => (IEnumerable <System.Data.Entity.Core.Metadata.Edm.NavigationProperty>)et.DeclaredNavigationProperties)).Single <System.Data.Entity.Core.Metadata.Edm.NavigationProperty>((Func <System.Data.Entity.Core.Metadata.Edm.NavigationProperty, bool>)(np =>
{
if (np.RelationshipType.Equals((object)associationType))
{
return(np.GetClrPropertyInfo().IsSameAs(this.NavigationProperty));
}
return(false);
}));
principalEnd = this.IsNavigationPropertyDeclaringTypePrincipal.Value ? associationType.GetOtherEnd(navigationProperty.ResultEnd) : navigationProperty.ResultEnd;
dependentEnd = associationType.GetOtherEnd(principalEnd);
if (associationType.SourceEnd != principalEnd)
{
associationType.SourceEnd = principalEnd;
associationType.TargetEnd = dependentEnd;
AssociationSet associationSet = model.Containers.SelectMany <EntityContainer, AssociationSet>((Func <EntityContainer, IEnumerable <AssociationSet> >)(ct => (IEnumerable <AssociationSet>)ct.AssociationSets)).Single <AssociationSet>((Func <AssociationSet, bool>)(aset => aset.ElementType == associationType));
EntitySet sourceSet = associationSet.SourceSet;
associationSet.SourceSet = associationSet.TargetSet;
associationSet.TargetSet = sourceSet;
}
}
if (principalEnd == null)
{
dependentEnd = associationType.TargetEnd;
}
}
this.ConfigureConstraint(associationType, dependentEnd, entityTypeConfiguration);
this.ConfigureDeleteAction(associationType.GetOtherEnd(dependentEnd));
}
/// <inheritdoc />
public virtual void Apply(NavigationProperty item, DbModel model)
{
Check.NotNull <NavigationProperty>(item, nameof(item));
Check.NotNull <DbModel>(model, nameof(model));
AssociationType association = item.Association;
if (association.Constraint != null)
{
return;
}
ForeignKeyAttribute foreignKeyAttribute = item.GetClrAttributes <ForeignKeyAttribute>().SingleOrDefault <ForeignKeyAttribute>();
AssociationEndMember principalEnd;
AssociationEndMember dependentEnd;
if (foreignKeyAttribute == null || !association.TryGuessPrincipalAndDependentEnds(out principalEnd, out dependentEnd) && !association.IsPrincipalConfigured())
{
return;
}
AssociationEndMember associationEndMember = dependentEnd ?? association.TargetEnd;
principalEnd = principalEnd ?? association.SourceEnd;
IEnumerable <string> dependentPropertyNames = ((IEnumerable <string>)foreignKeyAttribute.Name.Split(',')).Select <string, string>((Func <string, string>)(p => p.Trim()));
EntityType declaringEntityType = model.ConceptualModel.EntityTypes.Single <EntityType>((Func <EntityType, bool>)(e => e.DeclaredNavigationProperties.Contains(item)));
List <EdmProperty> list = ForeignKeyNavigationPropertyAttributeConvention.GetDependentProperties(associationEndMember.GetEntityType(), dependentPropertyNames, declaringEntityType, item).ToList <EdmProperty>();
ReferentialConstraint constraint = new ReferentialConstraint((RelationshipEndMember)principalEnd, (RelationshipEndMember)associationEndMember, (IEnumerable <EdmProperty>)principalEnd.GetEntityType().KeyProperties().ToList <EdmProperty>(), (IEnumerable <EdmProperty>)list);
IEnumerable <EdmProperty> source = associationEndMember.GetEntityType().KeyProperties();
if (source.Count <EdmProperty>() == constraint.ToProperties.Count <EdmProperty>() && source.All <EdmProperty>((Func <EdmProperty, bool>)(kp => constraint.ToProperties.Contains(kp))))
{
principalEnd.RelationshipMultiplicity = RelationshipMultiplicity.One;
if (associationEndMember.RelationshipMultiplicity.IsMany())
{
associationEndMember.RelationshipMultiplicity = RelationshipMultiplicity.ZeroOrOne;
}
}
if (principalEnd.IsRequired())
{
constraint.ToProperties.Each <EdmProperty, bool>((Func <EdmProperty, bool>)(p => p.Nullable = false));
}
association.Constraint = constraint;
}
private static void UpdatePrincipalTables(
DbDatabaseMapping databaseMapping, EntityType toTable, bool removeFks,
AssociationType associationType, EntityType et)
{
AssociationEndMember principalEnd, dependentEnd;
var endsToCheck = new List <AssociationEndMember>();
if (associationType.TryGuessPrincipalAndDependentEnds(out principalEnd, out dependentEnd))
{
endsToCheck.Add(principalEnd);
}
else if (associationType.SourceEnd.RelationshipMultiplicity == RelationshipMultiplicity.Many &&
associationType.TargetEnd.RelationshipMultiplicity == RelationshipMultiplicity.Many)
{
// many to many consider both ends
endsToCheck.Add(associationType.SourceEnd);
endsToCheck.Add(associationType.TargetEnd);
}
else
{
// 1:1 and 0..1:0..1
endsToCheck.Add(associationType.SourceEnd);
}
foreach (var end in endsToCheck)
{
if (end.GetEntityType() == et)
{
IEnumerable <KeyValuePair <EntityType, IEnumerable <EdmProperty> > > dependentTableInfos;
if (associationType.Constraint != null)
{
var originalDependentType = associationType.GetOtherEnd(end).GetEntityType();
var allDependentTypes = databaseMapping.Model.GetSelfAndAllDerivedTypes(originalDependentType);
dependentTableInfos =
allDependentTypes.Select(t => databaseMapping.GetEntityTypeMapping(t)).Where(
dm => dm != null)
.SelectMany(
dm => dm.MappingFragments
.Where(
tmf => associationType.Constraint.ToProperties
.All(
p =>
tmf.ColumnMappings.Any(
pm => pm.PropertyPath.First() == p))))
.Distinct((f1, f2) => f1.Table == f2.Table)
.Select(
df =>
new KeyValuePair <EntityType, IEnumerable <EdmProperty> >(
df.Table,
df.ColumnMappings.Where(
pm =>
associationType.Constraint.ToProperties.Contains(
pm.PropertyPath.First())).Select(
pm => pm.ColumnProperty)));
}
else
{
// IA
var associationSetMapping =
databaseMapping.EntityContainerMappings
.Single().AssociationSetMappings
.Single(asm => asm.AssociationSet.ElementType == associationType);
var dependentTable = associationSetMapping.Table;
var propertyMappings = associationSetMapping.SourceEndMapping.EndMember == end
? associationSetMapping.SourceEndMapping.PropertyMappings
: associationSetMapping.TargetEndMapping.PropertyMappings;
var dependentColumns = propertyMappings.Select(pm => pm.ColumnProperty);
dependentTableInfos = new[]
{
new KeyValuePair
<EntityType, IEnumerable <EdmProperty> >(
dependentTable, dependentColumns)
};
}
foreach (var tableInfo in dependentTableInfos)
{
foreach (
var fk in
tableInfo.Key.ForeignKeyBuilders.Where(
fk => fk.DependentColumns.SequenceEqual(tableInfo.Value)).ToArray(
))
{
if (removeFks)
{
tableInfo.Key.RemoveForeignKey(fk);
}
else
{
fk.PrincipalTable = toTable;
}
}
}
}
}
}