public static void Create_sets_properties_and_seals_the_instance() { var typeUsage = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); var associationType = new AssociationType("AssociationType", "Namespace", true, DataSpace.CSpace); var source = new EntityType("Source", "Namespace", DataSpace.CSpace); var target = new EntityType("Target", "Namespace", DataSpace.CSpace); var sourceEnd = new AssociationEndMember("SourceEnd", source); var targetEnd = new AssociationEndMember("TargetEnd", target); var navigationProperty = NavigationProperty.Create( "NavigationProperty", typeUsage, associationType, sourceEnd, targetEnd, new[] { new MetadataProperty( "TestProperty", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)), "value"), }); Assert.Equal("NavigationProperty", navigationProperty.Name); Assert.Same(typeUsage, navigationProperty.TypeUsage); Assert.Same(associationType, navigationProperty.RelationshipType); Assert.Same(sourceEnd, navigationProperty.FromEndMember); Assert.Same(targetEnd, navigationProperty.ToEndMember); Assert.True(navigationProperty.IsReadOnly); var metadataProperty = navigationProperty.MetadataProperties.SingleOrDefault(p => p.Name == "TestProperty"); Assert.NotNull(metadataProperty); Assert.Equal("value", metadataProperty.Value); }
/// <inheritdoc/> protected override bool MatchDependentKeyProperty( AssociationType associationType, AssociationEndMember dependentAssociationEnd, EdmProperty dependentProperty, EntityType principalEntityType, EdmProperty principalKeyProperty) { Check.NotNull(associationType, "associationType"); Check.NotNull(dependentAssociationEnd, "dependentAssociationEnd"); Check.NotNull(dependentProperty, "dependentProperty"); Check.NotNull(principalEntityType, "principalEntityType"); Check.NotNull(principalKeyProperty, "principalKeyProperty"); var otherEnd = associationType.GetOtherEnd(dependentAssociationEnd); var navigationProperty = dependentAssociationEnd.GetEntityType().NavigationProperties .SingleOrDefault(n => n.ResultEnd == otherEnd); if (navigationProperty == null) { return false; } return string.Equals( dependentProperty.Name, navigationProperty.Name + principalKeyProperty.Name, StringComparison.OrdinalIgnoreCase); }
public void Can_retrieve_properties() { var source = new EntityType("Source", "N", DataSpace.CSpace); var target = new EntityType("Target", "N", DataSpace.CSpace); var sourceEnd = new AssociationEndMember("SourceEnd", source); var targetEnd = new AssociationEndMember("TargetEnd", target); var associationType = AssociationType.Create( "AT", "N", true, DataSpace.CSpace, sourceEnd, targetEnd, null, null); var sourceSet = new EntitySet("SourceSet", "S", "T", "Q", source); var targetSet = new EntitySet("TargetSet", "S", "T", "Q", target); var associationSet = AssociationSet.Create( "AS", associationType, sourceSet, targetSet, null); var members = new List<EdmMember> { null, targetEnd }; var memberPath = new ModificationFunctionMemberPath(members, associationSet); Assert.Equal(members, memberPath.Members); Assert.Equal(targetEnd.Name, memberPath.AssociationSetEnd.Name); }
public void Can_create_mapping_and_get_association_end() { var associationEnd = new AssociationEndMember("E", new EntityType("E", "N", DataSpace.CSpace)); var mapping = new EndPropertyMapping(associationEnd); Assert.Same(associationEnd, mapping.AssociationEnd); }
// <summary> // Add the rel property induced by the specified relationship, (if the target // end has a multiplicity of one) // We only keep track of rel-properties that are "interesting" // </summary> // <param name="associationType"> the association relationship </param> // <param name="fromEnd"> source end of the relationship traversal </param> // <param name="toEnd"> target end of the traversal </param> private void AddRelProperty( AssociationType associationType, AssociationEndMember fromEnd, AssociationEndMember toEnd) { if (toEnd.RelationshipMultiplicity == RelationshipMultiplicity.Many) { return; } var prop = new RelProperty(associationType, fromEnd, toEnd); if (_interestingRelProperties == null || !_interestingRelProperties.Contains(prop)) { return; } var entityType = ((RefType)fromEnd.TypeUsage.EdmType).ElementType; List<RelProperty> propList; if (!_relPropertyMap.TryGetValue(entityType, out propList)) { propList = new List<RelProperty>(); _relPropertyMap[entityType] = propList; } propList.Add(prop); }
public void Create_throws_argument_exception_when_called_with_null_or_empty_arguments() { var source = new EntityType("Source", "Namespace", DataSpace.CSpace); var target = new EntityType("Target", "Namespace", DataSpace.CSpace); var sourceEnd = new AssociationEndMember("SourceEnd", source); var targetEnd = new AssociationEndMember("TargetEnd", target); var constraint = new ReferentialConstraint( sourceEnd, targetEnd, new[] { new EdmProperty("SourceProperty") }, new[] { new EdmProperty("TargetProperty") }); var associationType = AssociationType.Create( "AssociationType", "Namespace", true, DataSpace.CSpace, sourceEnd, targetEnd, constraint, Enumerable.Empty<MetadataProperty>()); var sourceSet = new EntitySet("SourceSet", "Schema", "Table", "Query", source); var targetSet = new EntitySet("TargetSet", "Schema", "Table", "Query", target); var metadataProperty = new MetadataProperty( "MetadataProperty", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)), "value"); // name is null Assert.Throws<ArgumentException>( () => AssociationSet.Create( null, associationType, sourceSet, targetSet, new [] { metadataProperty })); // name is empty Assert.Throws<ArgumentException>( () => AssociationSet.Create( String.Empty, associationType, sourceSet, targetSet, new[] { metadataProperty })); // type is null Assert.Throws<ArgumentNullException>( () => AssociationSet.Create( "AssociationSet", null, sourceSet, targetSet, new[] { metadataProperty })); }
public void IsRequired_should_return_true_when_end_kind_is_required() { var associationEnd = new AssociationEndMember("E", new EntityType("E", "N", DataSpace.CSpace)) { RelationshipMultiplicity = RelationshipMultiplicity.One }; Assert.True(associationEnd.IsRequired()); }
public static AssociationEndMember GetOtherEnd( this AssociationType associationType, AssociationEndMember associationEnd) { DebugCheck.NotNull(associationType); DebugCheck.NotNull(associationEnd); return associationEnd == associationType.SourceEnd ? associationType.TargetEnd : associationType.SourceEnd; }
public void Can_set_and_get_relationship_multiplicity() { var relationshipEndMember = new AssociationEndMember("E", new EntityType("E", "N", DataSpace.CSpace)); Assert.Equal(default(RelationshipMultiplicity), relationshipEndMember.RelationshipMultiplicity); relationshipEndMember.RelationshipMultiplicity = RelationshipMultiplicity.Many; Assert.Equal(RelationshipMultiplicity.Many, relationshipEndMember.RelationshipMultiplicity); }
internal override void Configure( AssociationType associationType, AssociationEndMember dependentEnd, EntityTypeConfiguration entityTypeConfiguration) { DebugCheck.NotNull(associationType); DebugCheck.NotNull(dependentEnd); DebugCheck.NotNull(entityTypeConfiguration); associationType.MarkIndependent(); }
public void Can_set_and_get_end_member() { var endPropertyMapping = new EndPropertyMapping(); Assert.Null(endPropertyMapping.AssociationEnd); var endMember = new AssociationEndMember("E", new EntityType("E", "N", DataSpace.CSpace)); endPropertyMapping.AssociationEnd = endMember; Assert.Same(endMember, endPropertyMapping.AssociationEnd); }
// <summary> // A name derived from a *:* association will be: FK_[Association Name]_[End Name]. Note that we are // getting the association name for *one* of the SSDL associations that are inferred from a CSDL *:* // association. The 'principalEnd' corresponds to the end of the *:* association that will become // the principal end in the 1:* association (where the * end is the newly-constructed entity corresponding // to the link table) // </summary> internal static string GetStorageAssociationSetNameFromManyToMany(AssociationSet associationSet, AssociationEndMember principalEnd) { Debug.Assert(associationSet != null, "AssociationSet should not be null"); Debug.Assert(principalEnd != null, "The principal end cannot be null"); var associationSetName = String.Empty; if (associationSet != null && principalEnd != null) { associationSetName = String.Format( CultureInfo.CurrentCulture, Resources.CodeViewManyToManyAssocName, associationSet.Name, principalEnd.Name); } return associationSetName; }
// <summary> // A name derived from a *:* association will be: FK_[Association Name]_[End Name]. Note that we are // getting the association name for *one* of the SSDL associations that are inferred from a CSDL *:* // association. The 'principalEnd' corresponds to the end of the *:* association that will become // the principal end in the 1:* association (where the * end is the newly-constructed entity corresponding // to the link table) // </summary> internal static string GetStorageAssociationNameFromManyToMany(AssociationEndMember principalEnd) { var association = principalEnd.DeclaringType as AssociationType; Debug.Assert( association != null, "The DeclaringType of the AssociationEndMember " + principalEnd.Name + " should be an AssociationType"); Debug.Assert(principalEnd != null, "The principal end cannot be null"); var associationName = String.Empty; if (association != null && principalEnd != null) { associationName = String.Format( CultureInfo.CurrentCulture, Resources.CodeViewManyToManyAssocName, association.Name, principalEnd.Name); } return associationName; }
internal WithRelationship( AssociationSet associationSet, AssociationEndMember fromEnd, EntityType fromEndEntityType, AssociationEndMember toEnd, EntityType toEndEntityType, IEnumerable<MemberPath> toEndEntityKeyMemberPaths) { m_associationSet = associationSet; m_fromEnd = fromEnd; m_fromEndEntityType = fromEndEntityType; m_toEnd = toEnd; m_toEndEntityType = toEndEntityType; m_toEndEntitySet = MetadataHelper.GetEntitySetAtEnd(associationSet, toEnd); m_toEndEntityKeyMemberPaths = toEndEntityKeyMemberPaths; }
protected override bool MatchDependentKeyProperty( AssociationType associationType, AssociationEndMember dependentAssociationEnd, EdmProperty dependentProperty, EntityType principalEntityType, EdmProperty principalKeyProperty) { Check.NotNull(associationType, "associationType"); Check.NotNull(dependentAssociationEnd, "dependentAssociationEnd"); Check.NotNull(dependentProperty, "dependentProperty"); Check.NotNull(principalEntityType, "principalEntityType"); Check.NotNull(principalKeyProperty, "principalKeyProperty"); return string.Equals( dependentProperty.Name, principalKeyProperty.Name, StringComparison.OrdinalIgnoreCase); }
public void Cannot_add_property_when_read_only() { var associationEnd = new AssociationEndMember("E", new EntityType("E", "N", DataSpace.CSpace)); var mapping = new EndPropertyMapping(associationEnd); mapping.SetReadOnly(); Assert.True(mapping.IsReadOnly); var scalarPropertyMapping = new ScalarPropertyMapping(new EdmProperty("P"), new EdmProperty("C", TypeUsage.Create(new PrimitiveType() { DataSpace = DataSpace.SSpace }))); Assert.Equal( Strings.OperationOnReadOnlyItem, Assert.Throws<InvalidOperationException>( () => mapping.AddPropertyMapping(scalarPropertyMapping)).Message); }
public void AssociationEndMembers_returns_correct_ends_after_modifying_SourceEnd() { var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace) { SourceEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace)), TargetEnd = new AssociationEndMember("T", new EntityType("E", "N", DataSpace.CSpace)) }; var newSource = new AssociationEndMember("S1", new EntityType("E", "N", DataSpace.CSpace)); associationType.SourceEnd = newSource; associationType.SetReadOnly(); Assert.Same(associationType.SourceEnd, newSource); Assert.Same(associationType.AssociationEndMembers[0], newSource); }
public void Can_get_and_set_ends_via_wrapper_properties() { var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace); Assert.Null(associationType.SourceEnd); Assert.Null(associationType.TargetEnd); var sourceEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace)); associationType.SourceEnd = sourceEnd; var targetEnd = new AssociationEndMember("T", new EntityType("E", "N", DataSpace.CSpace)); associationType.TargetEnd = targetEnd; Assert.Same(sourceEnd, associationType.SourceEnd); Assert.Same(targetEnd, associationType.TargetEnd); }
public void Can_set_and_get_to_role() { var toRole = new AssociationEndMember("D", new EntityType("E", "N", DataSpace.CSpace)); var referentialConstraint = new ReferentialConstraint( new AssociationEndMember("P", new EntityType("E", "N", DataSpace.CSpace)), toRole, new[] { EdmProperty.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)) }, new[] { EdmProperty.Primitive("D", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)) }); Assert.Same(toRole, referentialConstraint.ToRole); var toRole2 = new AssociationEndMember("D2", new EntityType("E", "N", DataSpace.CSpace)); referentialConstraint.ToRole = toRole2; Assert.Same(toRole2, referentialConstraint.ToRole); }
public void Can_set_and_get_dependent_end() { var dependentEnd1 = new AssociationEndMember("D", new EntityType()); var referentialConstraint = new ReferentialConstraint( new AssociationEndMember("P", new EntityType()), dependentEnd1, new[] { EdmProperty.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)) }, new[] { EdmProperty.Primitive("D", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)) }); Assert.Same(dependentEnd1, referentialConstraint.DependentEnd); var dependentEnd2 = new AssociationEndMember("D2", new EntityType()); referentialConstraint.DependentEnd = dependentEnd2; Assert.Same(dependentEnd2, referentialConstraint.DependentEnd); }
public void Can_get_association_ends_from_association_set() { var sourceEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace)); var targetEnd = new AssociationEndMember("T", new EntityType("E", "N", DataSpace.CSpace)); var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace); associationType.AddKeyMember(targetEnd); associationType.AddKeyMember(sourceEnd); var associationSet = new AssociationSet("A", associationType); Assert.Null(associationSet.SourceEnd); Assert.Null(associationSet.TargetEnd); associationSet.AddAssociationSetEnd(new AssociationSetEnd(new EntitySet(), associationSet, sourceEnd)); associationSet.AddAssociationSetEnd(new AssociationSetEnd(new EntitySet(), associationSet, targetEnd)); Assert.Same(sourceEnd, associationSet.SourceEnd); Assert.Same(targetEnd, associationSet.TargetEnd); }
/// <summary> /// Creates a read-only AssociationEndMember instance. /// </summary> /// <param name="name">The name of the association end member.</param> /// <param name="endRefType">The reference type for the end.</param> /// <param name="multiplicity">The multiplicity of the end.</param> /// <param name="deleteAction">Flag that indicates the delete behavior of the end.</param> /// <param name="metadataProperties">Metadata properties to be associated with the instance.</param> /// <returns>The newly created AssociationEndMember instance.</returns> /// <exception cref="ArgumentException">The specified name is null or empty.</exception> /// <exception cref="ArgumentNullException">The specified reference type is null.</exception> public static AssociationEndMember Create( string name, RefType endRefType, RelationshipMultiplicity multiplicity, OperationAction deleteAction, IEnumerable<MetadataProperty> metadataProperties) { Check.NotEmpty(name, "name"); Check.NotNull(endRefType, "endRefType"); var instance = new AssociationEndMember(name, endRefType, multiplicity); instance.DeleteBehavior = deleteAction; if (metadataProperties != null) { instance.AddMetadataProperties(metadataProperties.ToList()); } instance.SetReadOnly(); return instance; }
public static void Adding_a_NavigationProperty_to_an_EntityType_can_be_forced_when_read_only() { var typeUsage = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); var associationType = new AssociationType("AssociationType", "Namespace", true, DataSpace.CSpace); var source = new EntityType("Source", "Namespace", DataSpace.CSpace); var target = new EntityType("Target", "Namespace", DataSpace.CSpace); var sourceEnd = new AssociationEndMember("SourceEnd", source); var targetEnd = new AssociationEndMember("TargetEnd", target); var navigationProperty = NavigationProperty.Create( "NavigationProperty", typeUsage, associationType, sourceEnd, targetEnd, null); source.SetReadOnly(); Assert.True(source.IsReadOnly); Assert.Equal( Resources.Strings.OperationOnReadOnlyItem, Assert.Throws<InvalidOperationException>( () => source.AddMember(navigationProperty)).Message); Assert.Equal(0, source.Members.Count); source.AddNavigationProperty(navigationProperty); Assert.True(source.IsReadOnly); Assert.Equal(1, source.Members.Count); Assert.Same(navigationProperty, source.Members[0]); Assert.Equal( Resources.Strings.OperationOnReadOnlyItem, Assert.Throws<InvalidOperationException>( () => source.AddMember(navigationProperty)).Message); }
public static void Create_sets_properties_and_seals_the_instance() { var typeUsage = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); var associationType = new AssociationType("AssociationType", "Namespace", true, DataSpace.CSpace); var source = new EntityType("Source", "Namespace", DataSpace.CSpace); var target = new EntityType("Target", "Namespace", DataSpace.CSpace); var sourceEnd = new AssociationEndMember("SourceEnd", source); var targetEnd = new AssociationEndMember("TargetEnd", target); var navigationProperty = NavigationProperty.Create( "NavigationProperty", typeUsage, associationType, sourceEnd, targetEnd); Assert.Equal("NavigationProperty", navigationProperty.Name); Assert.Same(typeUsage, navigationProperty.TypeUsage); Assert.Same(associationType, navigationProperty.RelationshipType); Assert.Same(sourceEnd, navigationProperty.FromEndMember); Assert.Same(targetEnd, navigationProperty.ToEndMember); Assert.True(navigationProperty.IsReadOnly); }
public void Can_configure_ia_fk_parameters() { var modificationFunctionConfiguration = new ModificationFunctionConfiguration(); var mockPropertyInfo1 = new MockPropertyInfo(); var mockPropertyInfo2 = new MockPropertyInfo(); modificationFunctionConfiguration .Parameter(new PropertyPath(new[] { mockPropertyInfo1.Object, mockPropertyInfo2.Object }), "Foo"); var entitySet = new EntitySet(); entitySet.ChangeEntityContainerWithoutCollectionFixup(new EntityContainer("C", DataSpace.CSpace)); var property1 = new EdmProperty("P1"); property1.SetClrPropertyInfo(mockPropertyInfo1); var function = new EdmFunction("F", "N", DataSpace.SSpace); var functionParameter1 = new FunctionParameter(); var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace); var associationEndMember1 = new AssociationEndMember("AE1", new EntityType("E", "N", DataSpace.CSpace)) { RelationshipMultiplicity = RelationshipMultiplicity.Many }; var associationEndMember2 = new AssociationEndMember("AE2", new EntityType("E", "N", DataSpace.CSpace)) { RelationshipMultiplicity = RelationshipMultiplicity.One }; associationEndMember2.SetClrPropertyInfo(mockPropertyInfo1); associationType.SourceEnd = associationEndMember1; associationType.TargetEnd = associationEndMember2; var associationSet = new AssociationSet("AS", associationType); associationSet.AddAssociationSetEnd( new AssociationSetEnd(entitySet, associationSet, associationEndMember2)); modificationFunctionConfiguration.Configure( new StorageModificationFunctionMapping( entitySet, new EntityType("E", "N", DataSpace.CSpace), function, new[] { new StorageModificationFunctionParameterBinding( functionParameter1, new StorageModificationFunctionMemberPath( new EdmMember[] { property1, associationEndMember2 }, associationSet), false) }, null, null), ProviderRegistry.Sql2008_ProviderManifest); Assert.Equal("Foo", functionParameter1.Name); }
public void Can_configure_function_name_and_parameters() { var modificationFunctionConfiguration = new ModificationFunctionConfiguration(); modificationFunctionConfiguration.HasName("Foo", "Bar"); var mockPropertyInfo1 = new MockPropertyInfo(); var mockPropertyInfo2 = new MockPropertyInfo(); modificationFunctionConfiguration .Parameter(new PropertyPath(mockPropertyInfo1), "Foo"); modificationFunctionConfiguration .Parameter(new PropertyPath(new[] { mockPropertyInfo1.Object, mockPropertyInfo2.Object }), "Bar"); var entitySet = new EntitySet(); entitySet.ChangeEntityContainerWithoutCollectionFixup(new EntityContainer("C", DataSpace.CSpace)); var property1 = new EdmProperty("P1"); property1.SetClrPropertyInfo(mockPropertyInfo1); var property2 = new EdmProperty("P1"); property2.SetClrPropertyInfo(mockPropertyInfo2); var functionParameter1 = new FunctionParameter( "P1", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)), ParameterMode.In); var functionParameter2 = new FunctionParameter( "P2", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)), ParameterMode.In); var functionParameter3 = new FunctionParameter( "Foo", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)), ParameterMode.In); var function = new EdmFunction( "F", "N", DataSpace.SSpace, new EdmFunctionPayload { Parameters = new[] { functionParameter1, functionParameter2, functionParameter3 } }); var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace); var associationEndMember1 = new AssociationEndMember("AE1", new EntityType("E", "N", DataSpace.CSpace)) { RelationshipMultiplicity = RelationshipMultiplicity.Many }; var associationEndMember2 = new AssociationEndMember("AE2", new EntityType("E", "N", DataSpace.CSpace)) { RelationshipMultiplicity = RelationshipMultiplicity.Many }; associationType.SourceEnd = associationEndMember1; associationType.TargetEnd = associationEndMember2; var associationSet = new AssociationSet("AS", associationType); associationSet.AddAssociationSetEnd( new AssociationSetEnd(entitySet, associationSet, associationEndMember2)); modificationFunctionConfiguration.Configure( new StorageModificationFunctionMapping( entitySet, new EntityType("E", "N", DataSpace.CSpace), function, new[] { new StorageModificationFunctionParameterBinding( functionParameter1, new StorageModificationFunctionMemberPath( new EdmMember[] { property1, associationEndMember2 }, associationSet), false), new StorageModificationFunctionParameterBinding( functionParameter2, new StorageModificationFunctionMemberPath( new[] { property1, property2 }, null), false) }, null, null), ProviderRegistry.Sql2008_ProviderManifest); Assert.Equal("Foo", function.StoreFunctionNameAttribute); Assert.Equal("Bar", function.Schema); Assert.Equal("Foo", functionParameter1.Name); Assert.Equal("Bar", functionParameter2.Name); Assert.Equal("Foo1", functionParameter3.Name); }
private static AssociationType ConvertToAssociationType( Relationship element, DbProviderManifest providerManifest, Converter.ConversionCache convertedItemCache, Dictionary <SchemaElement, GlobalItem> newGlobalItems) { AssociationType associationType = new AssociationType(element.Name, element.Namespace, element.IsForeignKey, Converter.GetDataSpace(providerManifest)); newGlobalItems.Add((SchemaElement)element, (GlobalItem)associationType); foreach (RelationshipEnd end in (IEnumerable <IRelationshipEnd>)element.Ends) { EntityType endMemberType = (EntityType)Converter.LoadSchemaElement((System.Data.Entity.Core.SchemaObjectModel.SchemaType)end.Type, providerManifest, convertedItemCache, newGlobalItems); AssociationEndMember associationEndMember = Converter.InitializeAssociationEndMember(associationType, (IRelationshipEnd)end, endMemberType); Converter.AddOtherContent((SchemaElement)end, (MetadataItem)associationEndMember); foreach (OnOperation operation in (IEnumerable <OnOperation>)end.Operations) { if (operation.Operation == Operation.Delete) { OperationAction operationAction = OperationAction.None; switch (operation.Action) { case System.Data.Entity.Core.SchemaObjectModel.Action.None: operationAction = OperationAction.None; break; case System.Data.Entity.Core.SchemaObjectModel.Action.Cascade: operationAction = OperationAction.Cascade; break; } associationEndMember.DeleteBehavior = operationAction; } } if (end.Documentation != null) { associationEndMember.Documentation = Converter.ConvertToDocumentation(end.Documentation); } } for (int index = 0; index < element.Constraints.Count; ++index) { System.Data.Entity.Core.SchemaObjectModel.ReferentialConstraint constraint = element.Constraints[index]; AssociationEndMember member1 = (AssociationEndMember)associationType.Members[constraint.PrincipalRole.Name]; AssociationEndMember member2 = (AssociationEndMember)associationType.Members[constraint.DependentRole.Name]; EntityTypeBase elementType1 = ((RefType)member1.TypeUsage.EdmType).ElementType; EntityTypeBase elementType2 = ((RefType)member2.TypeUsage.EdmType).ElementType; ReferentialConstraint referentialConstraint = new ReferentialConstraint((RelationshipEndMember)member1, (RelationshipEndMember)member2, (IEnumerable <EdmProperty>)Converter.GetProperties(elementType1, constraint.PrincipalRole.RoleProperties), (IEnumerable <EdmProperty>)Converter.GetProperties(elementType2, constraint.DependentRole.RoleProperties)); if (constraint.Documentation != null) { referentialConstraint.Documentation = Converter.ConvertToDocumentation(constraint.Documentation); } if (constraint.PrincipalRole.Documentation != null) { referentialConstraint.FromRole.Documentation = Converter.ConvertToDocumentation(constraint.PrincipalRole.Documentation); } if (constraint.DependentRole.Documentation != null) { referentialConstraint.ToRole.Documentation = Converter.ConvertToDocumentation(constraint.DependentRole.Documentation); } associationType.AddReferentialConstraint(referentialConstraint); Converter.AddOtherContent((SchemaElement)element.Constraints[index], (MetadataItem)referentialConstraint); } if (element.Documentation != null) { associationType.Documentation = Converter.ConvertToDocumentation(element.Documentation); } Converter.AddOtherContent((SchemaElement)element, (MetadataItem)associationType); return(associationType); }
// Helper method to determine if the specified entityKey is in the given role and AssociationSet in this relationship entry internal bool IsSameAssociationSetAndRole( AssociationSet associationSet, AssociationEndMember associationMember, EntityKey entityKey) { Debug.Assert( associationSet.ElementType.AssociationEndMembers[0].Name == associationMember.Name || associationSet.ElementType.AssociationEndMembers[1].Name == associationMember.Name, "Expected associationMember to be one of the ends of the specified associationSet."); if (!ReferenceEquals(_entitySet, associationSet)) { return false; } // Find the end of the relationship that corresponds to the associationMember and see if it matches the EntityKey we are looking for if (_relationshipWrapper.AssociationSet.ElementType.AssociationEndMembers[0].Name == associationMember.Name) { return entityKey == Key0; } else { return entityKey == Key1; } }
/// <summary> /// Constrcut a new AssociationEnd member mapping metadata object /// </summary> /// <param name="edmAssociationEnd"></param> /// <param name="clrAssociationEnd"></param> internal ObjectAssociationEndMapping(AssociationEndMember edmAssociationEnd, AssociationEndMember clrAssociationEnd) : base(edmAssociationEnd, clrAssociationEnd) { }
protected virtual void Visit(AssociationEndMember associationEndMember) { Visit(associationEndMember.TypeUsage); }
public void Create_throws_argument_exception_when_called_with_invalid_arguments() { var source = new EntityType("Source", "Namespace", DataSpace.CSpace); var target = new EntityType("Target", "Namespace", DataSpace.CSpace); var sourceEnd = new AssociationEndMember("SourceEnd", source); var targetEnd = new AssociationEndMember("TargetEnd", target); var constraint = new ReferentialConstraint( sourceEnd, targetEnd, new[] { new EdmProperty("SourceProperty") }, new[] { new EdmProperty("TargetProperty") }); var metadataProperty = new MetadataProperty( "MetadataProperty", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)), "value"); Assert.Throws <ArgumentException>( () => AssociationType.Create( null, "Namespace", true, DataSpace.CSpace, sourceEnd, targetEnd, constraint, new[] { metadataProperty })); Assert.Throws <ArgumentException>( () => AssociationType.Create( String.Empty, "Namespace", true, DataSpace.CSpace, sourceEnd, targetEnd, constraint, new[] { metadataProperty })); Assert.Throws <ArgumentException>( () => AssociationType.Create( "AssociationType", null, true, DataSpace.CSpace, sourceEnd, targetEnd, constraint, new[] { metadataProperty })); Assert.Throws <ArgumentException>( () => AssociationType.Create( "AssociationType", String.Empty, true, DataSpace.CSpace, sourceEnd, targetEnd, constraint, new[] { metadataProperty })); }
// effects: Given the foreign key constraint, checks if the // constraint.ParentColumns are mapped to the entity set E'e keys in // C-space where E corresponds to the entity set corresponding to end // Returns true iff such a mapping exists in cell private bool CheckParentColumnsForForeignKey( Cell cell, IEnumerable<Cell> cells, AssociationEndMember parentEnd, ref List<ErrorLog.Record> errorList) { // The child columns are mapped to some end of cell.CQuery.Extent. ParentColumns // must correspond to the EntitySet for this end var relationSet = (AssociationSet)cell.CQuery.Extent; var endSet = MetadataHelper.GetEntitySetAtEnd(relationSet, parentEnd); // Check if the ParentColumns are mapped to endSet's keys // Find the entity set that they map to - if any var entitySet = FindEntitySetForColumnsMappedToEntityKeys(cells, ParentColumns); if (entitySet == null || endSet.Equals(entitySet) == false) { if (errorList == null) //lazily initialize only if there is an error { errorList = new List<ErrorLog.Record>(); } // childColumns are mapped to parentEnd but ParentColumns are not mapped to the end // corresponding to the parentEnd -- this is an error var message = Strings.ViewGen_Foreign_Key_ParentTable_NotMappedToEnd( ToUserString(), ChildTable.Name, cell.CQuery.Extent.Name, parentEnd.Name, ParentTable.Name, endSet.Name); var record = new ErrorLog.Record(ViewGenErrorCode.ForeignKeyParentTableNotMappedToEnd, message, cell, String.Empty); errorList.Add(record); return false; } return true; }
public void Create_checks_each_EntitySet_parameter_against_corresponding_AssociationEndMember() { var source = new EntityType("Source", "Namespace", DataSpace.CSpace); var target = new EntityType("Target", "Namespace", DataSpace.CSpace); var other = new EntityType("Other", "Namespace", DataSpace.CSpace); var sourceSet = new EntitySet("SourceSet", "Schema", "Table", "Query", source); var targetSet = new EntitySet("TargetSet", "Schema", "Table", "Query", target); var otherSet = new EntitySet("OtherSet", "Schema", "Table", "Query", other); var sourceEnd = new AssociationEndMember("SourceEnd", source); var targetEnd = new AssociationEndMember("TargetEnd", target); var associationTypeWithNonNullEndMembers = AssociationType.Create( "AssociationType", "Namespace", true, DataSpace.CSpace, sourceEnd, targetEnd, null, null); var associationTypeWithNullEndMembers = AssociationType.Create( "AssociationType", "Namespace", true, DataSpace.CSpace, null, // sourceEnd null, // targetEnd null, null); Assert.NotNull( AssociationSet.Create( "AssociationSet", associationTypeWithNonNullEndMembers, sourceSet, targetSet, null)); Assert.NotNull( AssociationSet.Create( "AssociationSet", associationTypeWithNullEndMembers, null, // sourceSet null, // targetSet null)); Assert.Equal( Resources.Strings.AssociationSet_EndEntityTypeMismatch, Assert.Throws <ArgumentException>( () => AssociationSet.Create( "AssociationSet", associationTypeWithNonNullEndMembers, otherSet, targetSet, null)).Message); Assert.Equal( Resources.Strings.AssociationSet_EndEntityTypeMismatch, Assert.Throws <ArgumentException>( () => AssociationSet.Create( "AssociationSet", associationTypeWithNonNullEndMembers, sourceSet, otherSet, null)).Message); Assert.Equal( Resources.Strings.AssociationSet_EndEntityTypeMismatch, Assert.Throws <ArgumentException>( () => AssociationSet.Create( "AssociationSet", associationTypeWithNonNullEndMembers, null, // sourceSet targetSet, null)).Message); Assert.Equal( Resources.Strings.AssociationSet_EndEntityTypeMismatch, Assert.Throws <ArgumentException>( () => AssociationSet.Create( "AssociationSet", associationTypeWithNonNullEndMembers, sourceSet, null, // targetSet null)).Message); Assert.Equal( Resources.Strings.AssociationSet_EndEntityTypeMismatch, Assert.Throws <ArgumentException>( () => AssociationSet.Create( "AssociationSet", associationTypeWithNullEndMembers, null, // sourceSet targetSet, null)).Message); Assert.Equal( Resources.Strings.AssociationSet_EndEntityTypeMismatch, Assert.Throws <ArgumentException>( () => AssociationSet.Create( "AssociationSet", associationTypeWithNullEndMembers, sourceSet, null, // targetSet null)).Message); }
public void WriteAssociationSetMapping_should_write_modification_function_mapping() { var fixture = new Fixture(); var entityType = new EntityType("E", "N", DataSpace.CSpace); var entitySet = new EntitySet("ES", "S", null, null, entityType); new EntityContainer("EC", DataSpace.SSpace).AddEntitySetBase(entitySet); var associationSet = new AssociationSet("AS", new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)); var associationEndMember1 = new AssociationEndMember("Source", new EntityType("E", "N", DataSpace.CSpace)); associationSet.AddAssociationSetEnd(new AssociationSetEnd(entitySet, associationSet, associationEndMember1)); var associationEndMember2 = new AssociationEndMember("Target", new EntityType("E", "N", DataSpace.CSpace)); associationSet.AddAssociationSetEnd(new AssociationSetEnd(entitySet, associationSet, associationEndMember2)); var storageModificationFunctionMapping = new ModificationFunctionMapping( associationSet, associationSet.ElementType, new EdmFunction("F", "N", DataSpace.SSpace, new EdmFunctionPayload()), new[] { new ModificationFunctionParameterBinding( new FunctionParameter( "P", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)), ParameterMode.In), new ModificationFunctionMemberPath( new EdmMember[] { new EdmProperty("K"), associationEndMember1 }, associationSet), true), new ModificationFunctionParameterBinding( new FunctionParameter( "P", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)), ParameterMode.In), new ModificationFunctionMemberPath( new EdmMember[] { new EdmProperty("K"), associationEndMember2 }, associationSet), false) }, null, null); var associationSetMapping = new AssociationSetMapping( associationSet, entitySet) { SourceEndMapping = new EndPropertyMapping { AssociationEnd = associationEndMember1 }, TargetEndMapping = new EndPropertyMapping { AssociationEnd = associationEndMember2 }, ModificationFunctionMapping = new AssociationSetModificationFunctionMapping( associationSet, storageModificationFunctionMapping, storageModificationFunctionMapping) }; fixture.Writer.WriteAssociationSetMappingElement(associationSetMapping); Assert.Equal( @"<AssociationSetMapping Name=""AS"" TypeName="".A"" StoreEntitySet=""E""> <EndProperty Name=""Source"" /> <EndProperty Name=""Target"" /> <ModificationFunctionMapping> <InsertFunction FunctionName=""N.F""> <EndProperty Name=""Source""> <ScalarProperty Name=""K"" ParameterName=""P"" Version=""Current"" /> </EndProperty> <EndProperty Name=""Target""> <ScalarProperty Name=""K"" ParameterName=""P"" Version=""Original"" /> </EndProperty> </InsertFunction> <DeleteFunction FunctionName=""N.F""> <EndProperty Name=""Source""> <ScalarProperty Name=""K"" ParameterName=""P"" Version=""Current"" /> </EndProperty> <EndProperty Name=""Target""> <ScalarProperty Name=""K"" ParameterName=""P"" Version=""Original"" /> </EndProperty> </DeleteFunction> </ModificationFunctionMapping> </AssociationSetMapping>", fixture.ToString()); }
// <summary> // Initializes a new instance of AssocationSetEnd // </summary> // <param name="entitySet"> Entity set that this end refers to </param> // <param name="parentSet"> The association set which this belongs to </param> // <param name="endMember"> The end member of the association set which this is an instance of </param> // <exception cref="System.ArgumentNullException">Thrown if either the role,entitySet, parentSet or endMember arguments are null</exception> internal AssociationSetEnd(EntitySet entitySet, AssociationSet parentSet, AssociationEndMember endMember) { _entitySet = Check.NotNull(entitySet, "entitySet"); _parentSet = Check.NotNull(parentSet, "parentSet"); _endMember = Check.NotNull(endMember, "endMember"); }
private static bool CheckEntitySetAgainstEndMember(EntitySet entitySet, AssociationEndMember endMember) { return((entitySet == null && endMember == null) || (entitySet != null && endMember != null && entitySet.ElementType == endMember.GetEntityType())); }