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()));
}