private static AssociationSet ConvertToAssociationSet( EntityContainerRelationshipSet relationshipSet, DbProviderManifest providerManifest, Converter.ConversionCache convertedItemCache, EntityContainer container, Dictionary <SchemaElement, GlobalItem> newGlobalItems) { AssociationType associationType = (AssociationType)Converter.LoadSchemaElement((System.Data.Entity.Core.SchemaObjectModel.SchemaType)relationshipSet.Relationship, providerManifest, convertedItemCache, newGlobalItems); AssociationSet parentSet = new AssociationSet(relationshipSet.Name, associationType); foreach (EntityContainerRelationshipSetEnd end in relationshipSet.Ends) { EntityType entityType = (EntityType)Converter.LoadSchemaElement((System.Data.Entity.Core.SchemaObjectModel.SchemaType)end.EntitySet.EntityType, providerManifest, convertedItemCache, newGlobalItems); AssociationEndMember member = (AssociationEndMember)associationType.Members[end.Name]; AssociationSetEnd associationSetEnd = new AssociationSetEnd(Converter.GetEntitySet(end.EntitySet, container), parentSet, member); Converter.AddOtherContent((SchemaElement)end, (MetadataItem)associationSetEnd); parentSet.AddAssociationSetEnd(associationSetEnd); if (end.Documentation != null) { associationSetEnd.Documentation = Converter.ConvertToDocumentation(end.Documentation); } } if (relationshipSet.Documentation != null) { parentSet.Documentation = Converter.ConvertToDocumentation(relationshipSet.Documentation); } Converter.AddOtherContent((SchemaElement)relationshipSet, (MetadataItem)parentSet); return(parentSet); }
public AssociationSetEndDetails( AssociationSetEnd associationSetEnd, RelationshipMultiplicity multiplicity, OperationAction deleteBehavior) { AssociationSetEnd = associationSetEnd; Multiplicity = multiplicity; DeleteBehavior = deleteBehavior; }
private void LogRelationEntityEnd(EntityKey mainKey, EntityKey relatedKey, System.Data.Entity.Core.Metadata.Edm.AssociationSetEnd relatedAssociationEnd, EntityState relationStatus, AuditingWidget widget) { var ctx = (widget.TrackedContext as IObjectContextAdapter).ObjectContext; var relatedEntry = ctx.ObjectStateManager.GetObjectStateEntry(mainKey); if (relatedEntry.State != EntityState.Detached && relatedEntry.State != EntityState.Unchanged) { var relatedAuditLog = widget.TrackedEntities[relatedEntry]; LogRelatedEntryDetails(relatedAssociationEnd.EntitySet.Name, relatedKey, relatedAuditLog, widget, relationStatus == EntityState.Added); } }
/// <summary> /// Initializes a new ModificationFunctionMemberPath instance. /// </summary> /// <param name="members">Gets the members in the path from the leaf (the member being bound) /// to the root of the structure.</param> /// <param name="associationSet">Gets the association set to which we are navigating /// via this member. If the value is null, this is not a navigation member path.</param> public ModificationFunctionMemberPath(IEnumerable<EdmMember> members, AssociationSet associationSet) { Check.NotNull(members, "members"); _members = new ReadOnlyCollection<EdmMember>(new List<EdmMember>(members)); if (null != associationSet) { Debug.Assert(2 == Members.Count, "Association bindings must always consist of the end and the key"); // find the association set end _associationSetEnd = associationSet.AssociationSetEnds[Members[1].Name]; } }
protected virtual void Visit(AssociationSetEnd associationSetEnd) { Visit(associationSetEnd.CorrespondingAssociationEndMember); Visit(associationSetEnd.EntitySet); Visit(associationSetEnd.ParentAssociationSet); }
internal RoleBoolean(AssociationSetEnd end) { m_metadataItem = end; }
private static DbRelatedEntityRef RelatedEntityRefFromAssociationSetEnd( EntityType constructedEntityType, DbNewInstanceExpression entityConstructor, AssociationSetEnd principalSetEnd, ReferentialConstraint fkConstraint) { var principalEntityType = (EntityType)TypeHelpers.GetEdmType<RefType>(fkConstraint.FromRole.TypeUsage).ElementType; IList<DbExpression> principalKeyValues = null; // Create Entity Property/DbExpression value pairs from the entity constructor DbExpression, // then join these with the principal/dependent property pairs from the FK constraint // to produce principal property name/DbExpression value pairs from which to create the principal ref. // // Ideally the code would be as below, but anonymous types break asmmeta: //var keyPropAndValue = // from pv in constructedEntityType.Properties.Select((p, idx) => new { DependentProperty = p, Value = entityConstructor.Arguments[idx] }) // join ft in fkConstraint.FromProperties.Select((fp, idx) => new { PrincipalProperty = fp, DependentProperty = fkConstraint.ToProperties[idx] }) // on pv.DependentProperty equals ft.DependentProperty // select new { PrincipalProperty = ft.PrincipalProperty.Name, Value = pv.Value }; // var keyPropAndValue = from pv in constructedEntityType.Properties.Select((p, idx) => Tuple.Create(p, entityConstructor.Arguments[idx])) // new { DependentProperty = p, Value = entityConstructor.Arguments[idx] }) join ft in fkConstraint.FromProperties.Select((fp, idx) => Tuple.Create(fp, fkConstraint.ToProperties[idx])) //new { PrincipalProperty = fp, DependentProperty = fkConstraint.ToProperties[idx] }) on pv.Item1 equals ft.Item2 //pv.DependentProperty equals ft.DependentProperty select Tuple.Create(ft.Item1.Name, pv.Item2); // new { PrincipalProperty = ft.PrincipalProperty.Name, Value = pv.Value }; // If there is only a single property in the principal's key, then there is no ordering concern. // Otherwise, create a dictionary of principal key property name to DbExpression value so that // when used as the arguments to the ref expression, the dependent property values - used here // as principal key property values - are in the correct order, which is the same order as the // key members themselves. // if (fkConstraint.FromProperties.Count == 1) { var singleKeyNameAndValue = keyPropAndValue.Single(); Debug.Assert(singleKeyNameAndValue.Item1 == fkConstraint.FromProperties[0].Name, "Unexpected single key property name"); principalKeyValues = new[] { singleKeyNameAndValue.Item2 }; } else { var keyValueMap = keyPropAndValue.ToDictionary(pav => pav.Item1, pav => pav.Item2, StringComparer.Ordinal); principalKeyValues = principalEntityType.KeyMemberNames.Select(memberName => keyValueMap[memberName]).ToList(); } // Create the ref to the principal entity based on the (now correctly ordered) key value expressions. // var principalRef = principalSetEnd.EntitySet.CreateRef(principalEntityType, principalKeyValues); var result = DbExpressionBuilder.CreateRelatedEntityRef(fkConstraint.ToRole, fkConstraint.FromRole, principalRef); return result; }
/// <summary> /// Converts an association set from SOM to metadata /// </summary> /// <param name="relationshipSet">The SOM element to process</param> /// <param name="providerManifest">The provider manifest to be used for conversion</param> /// <param name="convertedItemCache">The item collection for currently existing metadata objects</param> /// <param name="newGlobalItems">The new GlobalItem objects that are created as a result of this conversion</param> /// <param name="container"></param> /// <returns>The association set object resulting from the convert</returns> private static AssociationSet ConvertToAssociationSet( Som.EntityContainerRelationshipSet relationshipSet, DbProviderManifest providerManifest, ConversionCache convertedItemCache, EntityContainer container, Dictionary<Som.SchemaElement, GlobalItem> newGlobalItems) { Debug.Assert(relationshipSet.Relationship.RelationshipKind == RelationshipKind.Association); var associationType = (AssociationType)LoadSchemaElement( (Som.SchemaType)relationshipSet.Relationship, providerManifest, convertedItemCache, newGlobalItems); var associationSet = new AssociationSet(relationshipSet.Name, associationType); foreach (var end in relationshipSet.Ends) { //-- need the EntityType for the end var endEntityType = (EntityType)LoadSchemaElement( end.EntitySet.EntityType, providerManifest, convertedItemCache, newGlobalItems); //-- need to get the end member var endMember = (AssociationEndMember)associationType.Members[end.Name]; //-- create the end var associationSetEnd = new AssociationSetEnd( GetEntitySet(end.EntitySet, container), associationSet, endMember); AddOtherContent(end, associationSetEnd); associationSet.AddAssociationSetEnd(associationSetEnd); // Extract optional Documentation from the end element if (end.Documentation != null) { associationSetEnd.Documentation = ConvertToDocumentation(end.Documentation); } } // Extract the optional Documentation if (relationshipSet.Documentation != null) { associationSet.Documentation = ConvertToDocumentation(relationshipSet.Documentation); } AddOtherContent(relationshipSet, associationSet); return associationSet; }
// <summary> // Adds the given end to the collection of ends // </summary> internal void AddAssociationSetEnd(AssociationSetEnd associationSetEnd) { AssociationSetEnds.Source.Add(associationSetEnd); }
private static EdmProperty GetAssociatedFkColumn(AssociationSetEnd storeEnd, EdmProperty storeKeyProperty) { Debug.Assert(storeEnd != null, "storeEnd != null"); Debug.Assert(storeKeyProperty != null, "storeKeyProperty != null"); var constraint = GetReferentialConstraint(storeEnd.ParentAssociationSet); if (storeEnd.Name == constraint.FromRole.Name) { for (var i = 0; i < constraint.FromProperties.Count; i++) { if (constraint.FromProperties[i] == storeKeyProperty) { return constraint.ToProperties[i]; } } } return storeKeyProperty; }
private static EndPropertyMapping BuildEndPropertyMapping( AssociationSetEnd storeSetEnd, SimpleMappingContext mappingContext) { Debug.Assert(storeSetEnd != null, "storeSetEnd != null"); Debug.Assert(mappingContext != null, "mappingContext != null"); var endPropertyMapping = new EndPropertyMapping { AssociationEnd = mappingContext[storeSetEnd].CorrespondingAssociationEndMember }; foreach (EdmProperty storeKeyMember in storeSetEnd.EntitySet.ElementType.KeyMembers) { var modelKeyMember = mappingContext[storeKeyMember]; var storeFkTableMember = GetAssociatedFkColumn(storeSetEnd, storeKeyMember); endPropertyMapping.AddPropertyMapping( new ScalarPropertyMapping(modelKeyMember, storeFkTableMember)); } return endPropertyMapping; }
protected override void Visit(AssociationSetEnd associationSetEnd) { int index; if (!AddObjectToSeenListAndHashBuilder(associationSetEnd, out index)) { return; } AddObjectStartDumpToHashBuilder(associationSetEnd, index); #region Inner data visit AddObjectContentToHashBuilder(associationSetEnd.Identity); // Name is covered by Identity base.Visit(associationSetEnd); #endregion AddObjectEndDumpToHashBuilder(); }
// <summary> // Adds the given end to the collection of ends // </summary> internal void AddAssociationSetEnd(AssociationSetEnd associationSetEnd) { AssociationSetEnds.Source.Add(associationSetEnd); }
public void AddMapping(AssociationSetEnd storeAssociationSetEnd, AssociationSetEnd conceptualAssociationSetEnd) { _associationSetEndMappings.Add(storeAssociationSetEnd, conceptualAssociationSetEnd); }
public AssociationSetEnd this[AssociationSetEnd storeAssociationSetEnd] { get { return _associationSetEndMappings[storeAssociationSetEnd]; } }