internal void Configure( AssociationSetMapping associationSetMapping, DbDatabaseMapping databaseMapping, DbProviderManifest providerManifest) { DebugCheck.NotNull(associationSetMapping); DebugCheck.NotNull(databaseMapping); DebugCheck.NotNull(providerManifest); // We may apply configuration twice from two different NavigationPropertyConfiguration objects, // but that should be okay since they were validated as consistent above. // We still apply twice because each object may have different pieces of the full configuration. if (AssociationMappingConfiguration != null) { // This may replace a configuration previously set, but that's okay since we validated // consistency when processing the configuration above. associationSetMapping.SetConfiguration(this); AssociationMappingConfiguration .Configure(associationSetMapping, databaseMapping.Database, _navigationProperty); } if (_modificationStoredProceduresConfiguration != null) { if (associationSetMapping.ModificationFunctionMapping == null) { new ModificationFunctionMappingGenerator(providerManifest) .Generate(associationSetMapping, databaseMapping); } _modificationStoredProceduresConfiguration .Configure(associationSetMapping.ModificationFunctionMapping, providerManifest); } }
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; } } } } } }
internal override void Configure( AssociationSetMapping associationSetMapping, EdmModel database, PropertyInfo navigationProperty) { DebugCheck.NotNull(associationSetMapping); DebugCheck.NotNull(database); DebugCheck.NotNull(navigationProperty); var table = associationSetMapping.Table; if (_tableName != null) { table.SetTableName(_tableName); table.SetConfiguration(this); } var sourceEndIsPrimaryConfiguration = navigationProperty.IsSameAs( associationSetMapping.SourceEndMapping.AssociationEnd.GetClrPropertyInfo()); ConfigureColumnNames( sourceEndIsPrimaryConfiguration ? _leftKeyColumnNames : _rightKeyColumnNames, associationSetMapping.SourceEndMapping.PropertyMappings.ToList()); ConfigureColumnNames( sourceEndIsPrimaryConfiguration ? _rightKeyColumnNames : _leftKeyColumnNames, associationSetMapping.TargetEndMapping.PropertyMappings.ToList()); foreach (var annotation in _annotations) { table.AddAnnotation(XmlConstants.CustomAnnotationPrefix + annotation.Key, annotation.Value); } }
private static AssociationSetMapping BuildAssociationSetMapping( CollapsibleEntityAssociationSets collapsibleItem, EntityContainerMapping entityContainerMapping, SimpleMappingContext mappingContext) { Debug.Assert(collapsibleItem != null, "collapsibleItem != null"); Debug.Assert(entityContainerMapping != null, "entityContainerMapping != null"); Debug.Assert(mappingContext != null, "mappingContext != null"); var modelAssociationSet = mappingContext[collapsibleItem]; if (modelAssociationSet.ElementType.IsForeignKey) { return(null); } var associationSetMapping = new AssociationSetMapping( modelAssociationSet, collapsibleItem.EntitySet, entityContainerMapping); var count = collapsibleItem.AssociationSets.Count; if (count > 0) { associationSetMapping.SourceEndMapping = BuildEndPropertyMapping( collapsibleItem.GetStoreAssociationSetEnd(0).AssociationSetEnd, mappingContext); } if (count > 1) { associationSetMapping.TargetEndMapping = BuildEndPropertyMapping( collapsibleItem.GetStoreAssociationSetEnd(1).AssociationSetEnd, mappingContext); } return(associationSetMapping); }
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 IEnumerable <EdmProperty> GenerateIndependentForeignKeyColumns( EntityType principalEntityType, EntityType dependentEntityType, AssociationSetMapping associationSetMapping, EndPropertyMapping associationEndMapping, EntityType dependentTable, bool isPrimaryKeyColumn, NavigationProperty principalNavigationProperty) { foreach (EdmProperty keyProperty in principalEntityType.KeyProperties()) { string columnName = (principalNavigationProperty != null ? principalNavigationProperty.Name : principalEntityType.Name) + "_" + keyProperty.Name; EdmProperty foreignKeyColumn = this.MapTableColumn(keyProperty, columnName, false); dependentTable.AddColumn(foreignKeyColumn); if (isPrimaryKeyColumn) { dependentTable.AddKeyMember((EdmMember)foreignKeyColumn); } foreignKeyColumn.Nullable = associationEndMapping.AssociationEnd.IsOptional() || associationEndMapping.AssociationEnd.IsRequired() && dependentEntityType.BaseType != null; foreignKeyColumn.StoreGeneratedPattern = StoreGeneratedPattern.None; yield return(foreignKeyColumn); associationEndMapping.AddPropertyMapping(new ScalarPropertyMapping(keyProperty, foreignKeyColumn)); if (foreignKeyColumn.Nullable) { associationSetMapping.AddCondition((ConditionPropertyMapping) new IsNullConditionMapping(foreignKeyColumn, false)); } } }
public void Configure_should_rename_columns_when_right_keys_configured() { var database = new EdmModel(DataSpace.CSpace); var associationSetMapping = new AssociationSetMapping( new AssociationSet("AS", new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)), new EntitySet()) .Initialize(); var column = new EdmProperty("C", TypeUsage.Create(new PrimitiveType() { DataSpace = DataSpace.SSpace })); associationSetMapping.TargetEndMapping.AddPropertyMapping(new ScalarPropertyMapping(new EdmProperty("PK"), column)); var manyToManyAssociationMappingConfiguration = new ManyToManyAssociationMappingConfiguration(); manyToManyAssociationMappingConfiguration.MapRightKey("NewName"); var mockPropertyInfo = new MockPropertyInfo(); associationSetMapping.SourceEndMapping.AssociationEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace)); associationSetMapping.SourceEndMapping.AssociationEnd.SetClrPropertyInfo(mockPropertyInfo); manyToManyAssociationMappingConfiguration.Configure(associationSetMapping, database, mockPropertyInfo); Assert.Equal("NewName", column.Name); }
public void Configure_should_rename_table_when_table_configured() { var database = new EdmModel(DataSpace.SSpace); var table = database.AddTable("OriginalName"); var associationSetMapping = new AssociationSetMapping( new AssociationSet("AS", new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)), database.GetEntitySet(table)) .Initialize(); var manyToManyAssociationMappingConfiguration = new ManyToManyAssociationMappingConfiguration(); manyToManyAssociationMappingConfiguration.ToTable("NewName"); var mockPropertyInfo = new MockPropertyInfo(); associationSetMapping.SourceEndMapping.AssociationEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace)); associationSetMapping.SourceEndMapping.AssociationEnd.SetClrPropertyInfo(mockPropertyInfo); manyToManyAssociationMappingConfiguration.Configure(associationSetMapping, database, mockPropertyInfo); Assert.Equal("NewName", table.GetTableName().Name); Assert.Same(manyToManyAssociationMappingConfiguration, table.GetConfiguration()); }
private static bool TryGetWithRelationship( AssociationSetMapping colocatedAssociationSetMap, EntitySetBase thisExtent, MemberPath sRootNode, ref List <SlotInfo> foreignKeySlots, out WithRelationship withRelationship) { DebugCheck.NotNull(foreignKeySlots); withRelationship = null; //Get the map for foreign key end var foreignKeyEndMap = GetForeignKeyEndMapFromAssocitionMap(colocatedAssociationSetMap); if (foreignKeyEndMap == null || foreignKeyEndMap.AssociationEnd.RelationshipMultiplicity == RelationshipMultiplicity.Many) { return(false); } var toEnd = (AssociationEndMember)foreignKeyEndMap.AssociationEnd; var fromEnd = MetadataHelper.GetOtherAssociationEnd(toEnd); var toEndEntityType = (EntityType)((RefType)(toEnd.TypeUsage.EdmType)).ElementType; var fromEndEntityType = (EntityType)(((RefType)fromEnd.TypeUsage.EdmType).ElementType); // Get the member path for AssociationSet var associationSet = (AssociationSet)colocatedAssociationSetMap.Set; var prefix = new MemberPath(associationSet, toEnd); // Collect the member paths for edm scalar properties that belong to the target entity key. // These will be used as part of WITH RELATIONSHIP. // Get the key properties from edm type since the query parser depends on the order of key members var propertyMaps = foreignKeyEndMap.PropertyMappings.Cast <ScalarPropertyMapping>(); var toEndEntityKeyMemberPaths = new List <MemberPath>(); foreach (EdmProperty edmProperty in toEndEntityType.KeyMembers) { var scalarPropertyMaps = propertyMaps.Where(propMap => (propMap.Property.Equals(edmProperty))); Debug.Assert(scalarPropertyMaps.Count() == 1, "Can't Map the same column multiple times in the same end"); var scalarPropertyMap = scalarPropertyMaps.First(); // Create SlotInfo for Freign Key member that needs to be projected. var sSlot = new MemberProjectedSlot(new MemberPath(sRootNode, scalarPropertyMap.Column)); var endMemberKeyPath = new MemberPath(prefix, edmProperty); toEndEntityKeyMemberPaths.Add(endMemberKeyPath); foreignKeySlots.Add(new SlotInfo(true, true, sSlot, endMemberKeyPath)); } // Parent assignable from child: Ensures they are in the same hierarchy. if (thisExtent.ElementType.IsAssignableFrom(fromEndEntityType)) { // Now create the WITH RELATIONSHIP with all the needed info. withRelationship = new WithRelationship( associationSet, fromEnd, fromEndEntityType, toEnd, toEndEntityType, toEndEntityKeyMemberPaths); return(true); } else { return(false); } }
private static void MoveAssociationSetMappingDependents( AssociationSetMapping associationSetMapping, EndPropertyMapping dependentMapping, EntitySet toSet, bool useExistingColumns) { DebugCheck.NotNull(associationSetMapping); DebugCheck.NotNull(dependentMapping); DebugCheck.NotNull(toSet); var toTable = toSet.ElementType; dependentMapping.PropertyMappings.Each( pm => { var oldColumn = pm.Column; pm.Column = TableOperations.MoveColumnAndAnyConstraints( associationSetMapping.Table, toTable, oldColumn, useExistingColumns); associationSetMapping.Conditions .Where(cc => cc.Column == oldColumn) .Each(cc => cc.Column = pm.Column); }); associationSetMapping.StoreEntitySet = toSet; }
public static AssociationSetMapping Initialize( this AssociationSetMapping associationSetMapping) { associationSetMapping.SourceEndMapping = new EndPropertyMapping(); associationSetMapping.TargetEndMapping = new EndPropertyMapping(); return(associationSetMapping); }
public static Dictionary <string, string> GetLookupPropertiesMappingDictionary(this Edmx edmx, Type entityClrType) { string entityName = entityClrType.Name; Dictionary <string, string> mappingDictionary = new Dictionary <string, string>(); foreach (NavigationProperty navigationProperty in edmx.GetLookupProperties(entityClrType)) { string relationship = GetAdjustedText(navigationProperty.Relationship); string fromRole = navigationProperty.FromRole; string toRole = navigationProperty.ToRole; LinqToEdmx.Model.Conceptual.Association association = edmx.GetConceptualAssociation(relationship); LinqToEdmx.Model.Conceptual.AssociationEnd fromAssociation = edmx.GetConceptualAssociationEnd(relationship, fromRole); LinqToEdmx.Model.Conceptual.AssociationEnd toAssociation = edmx.GetConceptualAssociationEnd(relationship, toRole); AssociationSetMapping entityTypesMappingAssociation = edmx.GetMappingAssociationSet(entityName, relationship); foreach (EndProperty endProperty in entityTypesMappingAssociation.EndProperties) { if (endProperty.Name == toRole) { string columnName = endProperty.ScalarProperties[0].ColumnName; mappingDictionary.Add(navigationProperty.Name, columnName); } } } return(mappingDictionary); }
public void WriteAssociationSetMappingElement(AssociationSetMapping associationSetMapping) { DebugCheck.NotNull(associationSetMapping); _xmlWriter.WriteStartElement(MslConstructs.AssociationSetMappingElement); _xmlWriter.WriteAttributeString( MslConstructs.AssociationSetMappingNameAttribute, associationSetMapping.AssociationSet.Name); _xmlWriter.WriteAttributeString( MslConstructs.AssociationSetMappingTypeNameAttribute, _entityTypeNamespace + "." + associationSetMapping.AssociationSet.ElementType.Name); _xmlWriter.WriteAttributeString( MslConstructs.AssociationSetMappingStoreEntitySetAttribute, associationSetMapping.Table.Name); WriteAssociationEndMappingElement(associationSetMapping.SourceEndMapping); WriteAssociationEndMappingElement(associationSetMapping.TargetEndMapping); if (associationSetMapping.ModificationFunctionMapping != null) { WriteModificationFunctionMapping(associationSetMapping.ModificationFunctionMapping); } foreach (var conditionColumn in associationSetMapping.Conditions) { WriteConditionElement(conditionColumn); } _xmlWriter.WriteEndElement(); }
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); } }
public void Configure_should_throw_when_incorrect_number_of_columns_configured() { var database = new EdmModel(DataSpace.CSpace); var associationSetMapping = new AssociationSetMapping( new AssociationSet("AS", new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)), new EntitySet()) .Initialize(); var manyToManyAssociationMappingConfiguration = new ManyToManyAssociationMappingConfiguration(); manyToManyAssociationMappingConfiguration.MapLeftKey("Id1", "Id2"); var mockPropertyInfo = new MockPropertyInfo(); associationSetMapping.SourceEndMapping.AssociationEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace)); associationSetMapping.SourceEndMapping.AssociationEnd.SetClrPropertyInfo(mockPropertyInfo); Assert.Equal( Strings.IncorrectColumnCount("Id1, Id2"), Assert.Throws <InvalidOperationException>( () => manyToManyAssociationMappingConfiguration.Configure(associationSetMapping, database, mockPropertyInfo)).Message); }
internal AssociationSetTranslator(AssociationSetMapping setMapping) { if (null != setMapping) { m_mapping = setMapping.ModificationFunctionMapping; } }
internal static void AddRule(CommandProcessorContext cpc, AssociationSetMapping associationSetMapping) { Debug.Assert(associationSetMapping != null, "associationSetMapping should not be null"); IIntegrityCheck check = new EnforceAssociationSetMappingRules(cpc, associationSetMapping); cpc.AddIntegrityCheck(check); }
internal AssociationSetTranslator(AssociationSetMapping setMapping) { if (setMapping == null) { return; } this.m_mapping = setMapping.ModificationFunctionMapping; }
public void Initialize_should_initialize_ends() { var associationSetMapping = new AssociationSetMapping(new AssociationSet("AS", new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)), new EntitySet()).Initialize(); Assert.NotNull(associationSetMapping.SourceEndMapping); Assert.NotNull(associationSetMapping.TargetEndMapping); }
public void Can_get_and_set_configuration_annotation() { var associationSetMapping = new AssociationSetMapping(new AssociationSet("AS", new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)), new EntitySet()); associationSetMapping.SetConfiguration(42); Assert.Equal(42, associationSetMapping.GetConfiguration()); }
private CreateEndScalarPropertyCommand( AssociationSetMapping associationSetMapping, AssociationSetEnd associationSetEnd, Property entityProperty, Property tableColumn, bool enforceConstraints) { Initialize(entityProperty, tableColumn, enforceConstraints); CommandValidation.ValidateAssociationSetMapping(associationSetMapping); CommandValidation.ValidateAssociationSetEnd(associationSetEnd); _associationSetMapping = associationSetMapping; _associationSetEnd = associationSetEnd; }
public void Generate( AssociationSetMapping associationSetMapping, DbDatabaseMapping databaseMapping) { List <Tuple <ModificationFunctionMemberPath, EdmProperty> > list = ModificationFunctionMappingGenerator.GetIndependentFkColumns(associationSetMapping).ToList <Tuple <ModificationFunctionMemberPath, EdmProperty> >(); string functionNamePrefix = associationSetMapping.AssociationSet.ElementType.SourceEnd.GetEntityType().Name + associationSetMapping.AssociationSet.ElementType.TargetEnd.GetEntityType().Name; ModificationFunctionMapping functionMapping1 = this.GenerateFunctionMapping(ModificationOperator.Insert, (EntitySetBase)associationSetMapping.AssociationSet, (EntityTypeBase)associationSetMapping.AssociationSet.ElementType, databaseMapping, Enumerable.Empty <EdmProperty>(), (IEnumerable <Tuple <ModificationFunctionMemberPath, EdmProperty> >)list, (IList <ColumnMappingBuilder>) new ColumnMappingBuilder[0], (IEnumerable <EdmProperty>)null, functionNamePrefix); ModificationFunctionMapping functionMapping2 = this.GenerateFunctionMapping(ModificationOperator.Delete, (EntitySetBase)associationSetMapping.AssociationSet, (EntityTypeBase)associationSetMapping.AssociationSet.ElementType, databaseMapping, Enumerable.Empty <EdmProperty>(), (IEnumerable <Tuple <ModificationFunctionMemberPath, EdmProperty> >)list, (IList <ColumnMappingBuilder>) new ColumnMappingBuilder[0], (IEnumerable <EdmProperty>)null, functionNamePrefix); associationSetMapping.ModificationFunctionMapping = new AssociationSetModificationFunctionMapping(associationSetMapping.AssociationSet, functionMapping2, functionMapping1); }
/// <summary> /// Creates a Condition in the given AssociationSetMapping. /// Valid combinations are: /// 1. Send true or false for isNull, and null for conditionValue /// 2. Send null for isNull, and a non-empty string for conditionValue /// 3. Send null for isNull, and null for conditionValue /// You cannot send non-null values to both arguments. /// </summary> /// <param name="mappingFragment">The AssociationSetMapping to place this Condition; cannot be null.</param> /// <param name="tableColumn">This must be a valid Property from the S-Model.</param> internal CreateEndConditionCommand( AssociationSetMapping associationSetMapping, Property tableColumn, bool?isNull, string conditionValue) { CommandValidation.ValidateAssociationSetMapping(associationSetMapping); CommandValidation.ValidateTableColumn(tableColumn); _associationSetMapping = associationSetMapping; _tableColumn = tableColumn; _isNull = isNull; _conditionValue = conditionValue; }
public static AssociationSetMapping AddAssociationSetMapping( this DbDatabaseMapping databaseMapping, AssociationSet associationSet, EntitySet entitySet) { EntityContainerMapping containerMapping = databaseMapping.EntityContainerMappings.Single <EntityContainerMapping>(); AssociationSetMapping setMapping = new AssociationSetMapping(associationSet, entitySet, containerMapping).Initialize(); containerMapping.AddSetMapping(setMapping); return(setMapping); }
private void GenerateManyToManyAssociation( AssociationType associationType, DbDatabaseMapping databaseMapping) { EntityType entityType1 = associationType.SourceEnd.GetEntityType(); EntityType entityType2 = associationType.TargetEnd.GetEntityType(); EntityType dependentTable = databaseMapping.Database.AddTable(entityType1.Name + entityType2.Name); AssociationSetMapping associationSetMapping = AssociationTypeMappingGenerator.GenerateAssociationSetMapping(associationType, databaseMapping, associationType.SourceEnd, associationType.TargetEnd, dependentTable); this.GenerateIndependentForeignKeyConstraint(databaseMapping, entityType1, entityType2, dependentTable, associationSetMapping, associationSetMapping.SourceEndMapping, associationType.SourceEnd.Name, (AssociationEndMember)null, true); this.GenerateIndependentForeignKeyConstraint(databaseMapping, entityType2, entityType1, dependentTable, associationSetMapping, associationSetMapping.TargetEndMapping, associationType.TargetEnd.Name, (AssociationEndMember)null, true); }
protected override void InvokeInternal(CommandProcessorContext cpc) { var end = new EndProperty(AssociationSetMapping, null); end.Name.SetRefName(AssociationSetEnd); AssociationSetMapping.AddEndProperty(end); XmlModelHelper.NormalizeAndResolve(end); Debug.Assert(end.Name.Target != null, "Could not resolve AssociationSetEnd in an EndProperty"); _created = end; }
private static AssociationSetMapping GenerateAssociationSetMapping( AssociationType associationType, DbDatabaseMapping databaseMapping, AssociationEndMember principalEnd, AssociationEndMember dependentEnd, EntityType dependentTable) { AssociationSetMapping associationSetMapping = databaseMapping.AddAssociationSetMapping(databaseMapping.Model.GetAssociationSet(associationType), databaseMapping.Database.GetEntitySet(dependentTable)); associationSetMapping.StoreEntitySet = databaseMapping.Database.GetEntitySet(dependentTable); associationSetMapping.SourceEndMapping.AssociationEnd = principalEnd; associationSetMapping.TargetEndMapping.AssociationEnd = dependentEnd; return(associationSetMapping); }
private void GenerateIndependentForeignKeyConstraint( DbDatabaseMapping databaseMapping, EntityType principalEntityType, EntityType dependentEntityType, EntityType dependentTable, AssociationSetMapping associationSetMapping, EndPropertyMapping 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.AssociationEnd.DeleteBehavior != OperationAction.None ? associationEndMapping.AssociationEnd.DeleteBehavior : OperationAction.None }; var principalNavigationProperty = databaseMapping.Model.EntityTypes .SelectMany(e => e.DeclaredNavigationProperties) .SingleOrDefault(n => n.ResultEnd == principalEnd); dependentTable.AddForeignKey(foreignKeyConstraint); foreignKeyConstraint.DependentColumns = GenerateIndependentForeignKeyColumns( principalEntityType, dependentEntityType, associationSetMapping, associationEndMapping, dependentTable, isPrimaryKeyColumn, principalNavigationProperty); }
private IEnumerable <EdmProperty> GenerateIndependentForeignKeyColumns( EntityType principalEntityType, EntityType dependentEntityType, AssociationSetMapping associationSetMapping, EndPropertyMapping associationEndMapping, EntityType dependentTable, bool isPrimaryKeyColumn, NavigationProperty principalNavigationProperty) { DebugCheck.NotNull(principalEntityType); DebugCheck.NotNull(associationEndMapping); DebugCheck.NotNull(dependentTable); foreach (var property in principalEntityType.KeyProperties()) { var columnName = ((principalNavigationProperty != null) ? principalNavigationProperty.Name : principalEntityType.Name) + "_" + property.Name; var foreignKeyColumn = MapTableColumn(property, columnName, false); dependentTable.AddColumn(foreignKeyColumn); if (isPrimaryKeyColumn) { dependentTable.AddKeyMember(foreignKeyColumn); } foreignKeyColumn.Nullable = associationEndMapping.AssociationEnd.IsOptional() || (associationEndMapping.AssociationEnd.IsRequired() && dependentEntityType.BaseType != null); foreignKeyColumn.StoreGeneratedPattern = StoreGeneratedPattern.None; yield return(foreignKeyColumn); associationEndMapping.AddPropertyMapping(new ScalarPropertyMapping(property, foreignKeyColumn)); if (foreignKeyColumn.Nullable) { associationSetMapping .AddCondition(new IsNullConditionMapping(foreignKeyColumn, false)); } } }
private static EndPropertyMapping GetForeignKeyEndMapFromAssocitionMap( AssociationSetMapping colocatedAssociationSetMap) { MappingFragment mappingFragment = colocatedAssociationSetMap.TypeMappings.First <TypeMapping>().MappingFragments.First <MappingFragment>(); IEnumerable <EdmMember> keyMembers = (IEnumerable <EdmMember>)colocatedAssociationSetMap.StoreEntitySet.ElementType.KeyMembers; foreach (EndPropertyMapping propertyMapping in mappingFragment.PropertyMappings) { EndPropertyMapping endMap = propertyMapping; if (endMap.StoreProperties.SequenceEqual <EdmMember>(keyMembers, (IEqualityComparer <EdmMember>)System.Collections.Generic.EqualityComparer <EdmMember> .Default)) { return(mappingFragment.PropertyMappings.OfType <EndPropertyMapping>().Where <EndPropertyMapping>((Func <EndPropertyMapping, bool>)(eMap => !eMap.Equals((object)endMap))).First <EndPropertyMapping>()); } } return((EndPropertyMapping)null); }
// <summary> // Initialize a translator for the given association set mapping. // </summary> // <param name="setMapping"> Association set mapping. </param> // <returns> Translator. </returns> internal static ModificationFunctionMappingTranslator CreateAssociationSetTranslator( AssociationSetMapping setMapping) { return new AssociationSetTranslator(setMapping); }