public void WriteEntitySetMappingElement(StorageEntitySetMapping entitySetMapping)
{
DebugCheck.NotNull(entitySetMapping);
_xmlWriter.WriteStartElement(StorageMslConstructs.EntitySetMappingElement);
_xmlWriter.WriteAttributeString(StorageMslConstructs.EntitySetMappingNameAttribute, entitySetMapping.EntitySet.Name);
foreach (var entityTypeMapping in entitySetMapping.EntityTypeMappings)
{
WriteEntityTypeMappingElement(entityTypeMapping);
}
foreach (var modificationFunctionMapping in entitySetMapping.ModificationFunctionMappings)
{
_xmlWriter.WriteStartElement(StorageMslConstructs.EntityTypeMappingElement);
_xmlWriter.WriteAttributeString(
StorageMslConstructs.EntityTypeMappingTypeNameAttribute,
GetEntityTypeName(_entityTypeNamespace + "." + modificationFunctionMapping.EntityType.Name, false));
WriteModificationFunctionMapping(modificationFunctionMapping);
_xmlWriter.WriteEndElement();
}
_xmlWriter.WriteEndElement();
}
public void WriteMappingFragment_should_write_store_entity_set_name()
{
var fixture = new Fixture();
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = new EntitySet("ES", "S", null, null, entityType);
var entityContainer = new EntityContainer("EC", DataSpace.SSpace);
entityContainer.AddEntitySetBase(entitySet);
var storageEntitySetMapping
= new StorageEntitySetMapping(
entitySet,
new StorageEntityContainerMapping(entityContainer));
StorageTypeMapping typeMapping = new StorageEntityTypeMapping(storageEntitySetMapping);
var mappingFragment = new StorageMappingFragment(entitySet, typeMapping, false);
fixture.Writer.WriteMappingFragmentElement(mappingFragment);
Assert.Equal(
@"<MappingFragment StoreEntitySet=""ES"" />",
fixture.ToString());
}
public void Can_clear_modification_function_mappings()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = new EntitySet("S", "N", null, null, entityType);
var function = new EdmFunction("F", "N", DataSpace.SSpace, new EdmFunctionPayload());
var container = new EntityContainer("C", DataSpace.CSpace);
container.AddEntitySetBase(entitySet);
var entitySetMapping =
new StorageEntitySetMapping(
entitySet,
new StorageEntityContainerMapping(container));
var functionMapping =
new StorageModificationFunctionMapping(
entitySet,
entityType,
function,
Enumerable.Empty<StorageModificationFunctionParameterBinding>(),
null,
null);
var entityFunctionMappings =
new StorageEntityTypeModificationFunctionMapping(entityType, functionMapping, null, null);
entitySetMapping.AddModificationFunctionMapping(entityFunctionMappings);
Assert.Equal(1, entitySetMapping.ModificationFunctionMappings.Count());
entitySetMapping.ClearModificationFunctionMappings();
Assert.Equal(0, entitySetMapping.ModificationFunctionMappings.Count());
}
public static void RemoveDefaultDiscriminator(
this StorageMappingFragment entityTypeMappingFragment, StorageEntitySetMapping entitySetMapping)
{
DebugCheck.NotNull(entityTypeMappingFragment);
var discriminatorColumn = entityTypeMappingFragment.RemoveDefaultDiscriminatorCondition();
if (discriminatorColumn != null)
{
var table = entityTypeMappingFragment.Table;
table.Properties
.Where(c => c.Name.Equals(discriminatorColumn.Name, StringComparison.Ordinal))
.ToList()
.Each(table.RemoveMember);
}
if (entitySetMapping != null
&& entityTypeMappingFragment.IsConditionOnlyFragment()
&&
!entityTypeMappingFragment.ColumnConditions.Any())
{
var entityTypeMapping =
entitySetMapping.EntityTypeMappings.Single(
etm => etm.MappingFragments.Contains(entityTypeMappingFragment));
entityTypeMapping.RemoveFragment(entityTypeMappingFragment);
if (entityTypeMapping.MappingFragments.Count == 0)
{
entitySetMapping.RemoveTypeMapping(entityTypeMapping);
}
}
}
public void Can_clear_modification_function_mappings()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = new EntitySet("S", "N", null, null, entityType);
var function = new EdmFunction("F", "N", DataSpace.SSpace, new EdmFunctionPayload());
var container = new EntityContainer("C", DataSpace.CSpace);
container.AddEntitySetBase(entitySet);
var entitySetMapping =
new StorageEntitySetMapping(
entitySet,
new StorageEntityContainerMapping(container));
var functionMapping =
new StorageModificationFunctionMapping(
entitySet,
entityType,
function,
Enumerable.Empty <StorageModificationFunctionParameterBinding>(),
null,
null);
var entityFunctionMappings =
new StorageEntityTypeModificationFunctionMapping(entityType, functionMapping, null, null);
entitySetMapping.AddModificationFunctionMapping(entityFunctionMappings);
Assert.Equal(1, entitySetMapping.ModificationFunctionMappings.Count());
entitySetMapping.ClearModificationFunctionMappings();
Assert.Equal(0, entitySetMapping.ModificationFunctionMappings.Count());
}
public void Can_get_entity_set()
{
var entityContainerMapping = new StorageEntityContainerMapping(new EntityContainer());
var entitySet = new EntitySet();
var entitySetMapping = new StorageEntitySetMapping(entitySet, entityContainerMapping);
Assert.Same(entitySet, entitySetMapping.EntitySet);
}
public void Can_get_entity_set()
{
var entityContainerMapping = new StorageEntityContainerMapping(new EntityContainer("C", DataSpace.CSpace));
var entitySet = new EntitySet();
var entitySetMapping = new StorageEntitySetMapping(entitySet, entityContainerMapping);
Assert.Same(entitySet, entitySetMapping.EntitySet);
}
public void Can_get_entity_set()
{
var entitySet = new EntitySet();
var storageSetMapping
= new StorageEntitySetMapping(
entitySet,
new StorageEntityContainerMapping(new EntityContainer("C", DataSpace.CSpace)));
Assert.Same(entitySet, storageSetMapping.EntitySet);
}
public void Can_get_container_mapping()
{
var containerMapping = new StorageEntityContainerMapping(new EntityContainer("C", DataSpace.CSpace));
var storageSetMapping
= new StorageEntitySetMapping(
new EntitySet(),
containerMapping);
Assert.Same(containerMapping, storageSetMapping.EntityContainerMapping);
}
public void Can_get_container_mapping()
{
var containerMapping = new StorageEntityContainerMapping(new EntityContainer("C", DataSpace.CSpace));
var storageSetMapping
= new StorageEntitySetMapping(
new EntitySet(),
containerMapping);
Assert.Same(containerMapping, storageSetMapping.EntityContainerMapping);
}
public void Can_not_add_null_mapping()
{
var storageSetMapping
= new StorageEntitySetMapping(
new EntitySet(),
new StorageEntityContainerMapping(new EntityContainer("C", DataSpace.CSpace)));
Assert.Equal(
"typeMapping",
Assert.Throws<ArgumentNullException>(() => storageSetMapping.AddTypeMapping(null)).ParamName);
}
public void IsOfType_collection_empty()
{
var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace);
var setMapping
= new StorageEntitySetMapping(
new EntitySet(),
new StorageEntityContainerMapping(new EntityContainer("C", DataSpace.CSpace)));
Assert.Empty(new StorageAssociationTypeMapping(associationType, setMapping).IsOfTypes);
}
public void Can_not_add_null_mapping()
{
var storageSetMapping
= new StorageEntitySetMapping(
new EntitySet(),
new StorageEntityContainerMapping(new EntityContainer("C", DataSpace.CSpace)));
Assert.Equal(
"typeMapping",
Assert.Throws <ArgumentNullException>(() => storageSetMapping.AddTypeMapping(null)).ParamName);
}
public void Can_get_set_mapping()
{
var storageSetMapping
= new StorageEntitySetMapping(
new EntitySet(),
new StorageEntityContainerMapping(new EntityContainer("C", DataSpace.CSpace)));
var storageTypeMapping
= new StorageEntityTypeMapping(storageSetMapping);
Assert.Same(storageSetMapping, storageTypeMapping.SetMapping);
}
public void Can_get_set_mapping()
{
var storageSetMapping
= new StorageEntitySetMapping(
new EntitySet(),
new StorageEntityContainerMapping(new EntityContainer("C", DataSpace.CSpace)));
var storageTypeMapping
= new StorageEntityTypeMapping(storageSetMapping);
Assert.Same(storageSetMapping, storageTypeMapping.SetMapping);
}
public void Can_get_association_type()
{
var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace);
var setMapping
= new StorageEntitySetMapping(
new EntitySet(),
new StorageEntityContainerMapping(new EntityContainer("C", DataSpace.CSpace)));
Assert.Same(
associationType,
new StorageAssociationTypeMapping(associationType, setMapping).AssociationType);
}
public void Association_type_returned_in_type_collection()
{
var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace);
var setMapping
= new StorageEntitySetMapping(
new EntitySet(),
new StorageEntityContainerMapping(new EntityContainer("C", DataSpace.CSpace)));
Assert.Same(
associationType,
new StorageAssociationTypeMapping(associationType, setMapping).Types.Single());
}
public void Can_get_entity_set_mappings()
{
var entityContainerMapping = new StorageEntityContainerMapping(new EntityContainer());
Assert.Empty(entityContainerMapping.EntitySetMappings);
var entitySetMapping
= new StorageEntitySetMapping(
new EntitySet("ES", null, null, null, new EntityType()), entityContainerMapping);
entityContainerMapping.AddEntitySetMapping(entitySetMapping);
Assert.Same(entitySetMapping, entityContainerMapping.EntitySetMappings.Single());
}
public static void GetIdentity_of_StorageSetMapping_returns_expected_value()
{
var entityType = new EntityType("ET", "N", DataSpace.CSpace);
var entitySet = new EntitySet("ES", "S", "T", null, entityType);
var associationType = new AssociationType("AT", "N", false, DataSpace.CSpace);
var associationSet = new AssociationSet("AS", associationType);
var entitySetMapping = new StorageEntitySetMapping(entitySet, null);
var associationSetMapping = new StorageAssociationSetMapping(associationSet, entitySet);
Assert.Equal(entitySet.Identity,
BaseMetadataMappingVisitor.IdentityHelper.GetIdentity(entitySetMapping));
Assert.Equal(associationSet.Identity,
BaseMetadataMappingVisitor.IdentityHelper.GetIdentity(associationSetMapping));
}
public void Can_get_entity_type_mappings()
{
var entityContainerMapping = new StorageEntityContainerMapping(new EntityContainer("C", DataSpace.CSpace));
var entitySetMapping = new StorageEntitySetMapping(new EntitySet(), entityContainerMapping);
Assert.Empty(entitySetMapping.EntityTypeMappings);
var entityTypeMapping
= new StorageEntityTypeMapping(
new StorageEntitySetMapping(new EntitySet(), entityContainerMapping));
entitySetMapping.AddTypeMapping(entityTypeMapping);
Assert.Same(entityTypeMapping, entitySetMapping.EntityTypeMappings.Single());
}
public void Can_get_entity_type_mappings()
{
var entityContainerMapping = new StorageEntityContainerMapping(new EntityContainer("C", DataSpace.CSpace));
var entitySetMapping = new StorageEntitySetMapping(new EntitySet(), entityContainerMapping);
Assert.Empty(entitySetMapping.EntityTypeMappings);
var entityTypeMapping
= new StorageEntityTypeMapping(
new StorageEntitySetMapping(new EntitySet(), entityContainerMapping));
entitySetMapping.AddTypeMapping(entityTypeMapping);
Assert.Same(entityTypeMapping, entitySetMapping.EntityTypeMappings.Single());
}
public void Can_get_entity_set_mappings()
{
var entityContainerMapping = new StorageEntityContainerMapping(new EntityContainer("C", DataSpace.CSpace));
Assert.Empty(entityContainerMapping.EntitySetMappings);
Assert.Empty(entityContainerMapping.EntitySetMaps);
var entitySetMapping
= new StorageEntitySetMapping(
new EntitySet("ES", null, null, null, new EntityType("E", "N", DataSpace.CSpace)), entityContainerMapping);
entityContainerMapping.AddEntitySetMapping(entitySetMapping);
Assert.Same(entitySetMapping, entityContainerMapping.EntitySetMappings.Single());
Assert.Same(entitySetMapping, entityContainerMapping.EntitySetMaps.Single());
}
public void WriteEntitySetMappingElement_should_write_modification_function_mappings()
{
var fixture = new Fixture();
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = new EntitySet("ES", "S", null, null, entityType);
var entityContainer = new EntityContainer("EC", DataSpace.SSpace);
entityContainer.AddEntitySetBase(entitySet);
var storageEntitySetMapping
= new StorageEntitySetMapping(
entitySet,
new StorageEntityContainerMapping(entityContainer));
var storageModificationFunctionMapping
= new StorageModificationFunctionMapping(
entitySet,
entityType,
new EdmFunction("F", "N", DataSpace.SSpace, new EdmFunctionPayload()),
Enumerable.Empty<StorageModificationFunctionParameterBinding>(),
null,
null);
storageEntitySetMapping.AddModificationFunctionMapping(
new StorageEntityTypeModificationFunctionMapping(
entityType,
storageModificationFunctionMapping,
storageModificationFunctionMapping,
storageModificationFunctionMapping));
fixture.Writer.WriteEntitySetMappingElement(storageEntitySetMapping);
Assert.Equal(
@"<EntitySetMapping Name=""ES"">
<EntityTypeMapping TypeName="".E"">
<ModificationFunctionMapping>
<InsertFunction FunctionName=""N.F"" />
<UpdateFunction FunctionName=""N.F"" />
<DeleteFunction FunctionName=""N.F"" />
</ModificationFunctionMapping>
</EntityTypeMapping>
</EntitySetMapping>",
fixture.ToString());
}
private static bool HasBaseWithIsTypeOf(StorageEntitySetMapping entitySetMapping, EntityType entityType)
{
var baseType = entityType.BaseType;
while (baseType != null)
{
if (entitySetMapping.EntityTypeMappings
.Where(etm => etm.EntityType == baseType)
.Any(etm => etm.IsHierarchyMapping))
{
return true;
}
baseType = baseType.BaseType;
}
return false;
}
public void Can_add_remove_type_mapping()
{
var storageSetMapping
= new StorageEntitySetMapping(
new EntitySet(),
new StorageEntityContainerMapping(new EntityContainer("C", DataSpace.CSpace)));
Assert.Empty(storageSetMapping.TypeMappings);
var entityTypeMapping = new StorageEntityTypeMapping(storageSetMapping);
storageSetMapping.AddTypeMapping(entityTypeMapping);
Assert.Same(entityTypeMapping, storageSetMapping.TypeMappings.Single());
storageSetMapping.RemoveTypeMapping(entityTypeMapping);
Assert.Empty(storageSetMapping.TypeMappings);
}
public void Can_add_remove_type_mapping()
{
var storageSetMapping
= new StorageEntitySetMapping(
new EntitySet(),
new StorageEntityContainerMapping(new EntityContainer()));
Assert.Empty(storageSetMapping.TypeMappings);
var entityTypeMapping = new StorageEntityTypeMapping(storageSetMapping);
storageSetMapping.AddTypeMapping(entityTypeMapping);
Assert.Same(entityTypeMapping, storageSetMapping.TypeMappings.Single());
storageSetMapping.RemoveTypeMapping(entityTypeMapping);
Assert.Empty(storageSetMapping.TypeMappings);
}
public void Can_add_remove_mapping_fragment()
{
var storageSetMapping
= new StorageEntitySetMapping(
new EntitySet(),
new StorageEntityContainerMapping(new EntityContainer()));
var storageTypeMapping
= new StorageEntityTypeMapping(storageSetMapping);
Assert.Empty(storageTypeMapping.MappingFragments);
var mappingFragment = new StorageMappingFragment(new EntitySet(), storageTypeMapping, false);
storageTypeMapping.AddFragment(mappingFragment);
Assert.Same(mappingFragment, storageTypeMapping.MappingFragments.Single());
storageTypeMapping.RemoveFragment(mappingFragment);
Assert.Empty(storageTypeMapping.MappingFragments);
}
public void Can_add_remove_mapping_fragment()
{
var storageSetMapping
= new StorageEntitySetMapping(
new EntitySet(),
new StorageEntityContainerMapping(new EntityContainer()));
var storageTypeMapping
= new StorageEntityTypeMapping(storageSetMapping);
Assert.Empty(storageTypeMapping.MappingFragments);
var mappingFragment = new StorageMappingFragment(new EntitySet(), storageTypeMapping, false);
storageTypeMapping.AddFragment(mappingFragment);
Assert.Same(mappingFragment, storageTypeMapping.MappingFragments.Single());
storageTypeMapping.RemoveFragment(mappingFragment);
Assert.Empty(storageTypeMapping.MappingFragments);
}
public void Can_get_modification_function_mappings()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = new EntitySet("S", "N", null, null, entityType);
var function = new EdmFunction(
"F", "N", DataSpace.CSpace,
new EdmFunctionPayload
{
IsFunctionImport = true
});
var container = new EntityContainer("C", DataSpace.CSpace);
container.AddEntitySetBase(entitySet);
container.AddFunctionImport(function);
var entitySetMapping =
new StorageEntitySetMapping(
entitySet,
new StorageEntityContainerMapping(container));
var functionMapping =
new StorageModificationFunctionMapping(
entitySet,
entityType,
function,
Enumerable.Empty <StorageModificationFunctionParameterBinding>(),
null,
null);
var entityFunctionMappings =
new StorageEntityTypeModificationFunctionMapping(entityType, functionMapping, null, null);
entitySetMapping.AddModificationFunctionMapping(entityFunctionMappings);
Assert.Same(entityFunctionMappings, entitySetMapping.ModificationFunctionMappings.Single());
}
public void Generate(
EntityType entityType,
IEnumerable<EdmProperty> properties,
StorageEntitySetMapping entitySetMapping,
StorageMappingFragment entityTypeMappingFragment,
IList<EdmProperty> propertyPath,
bool createNewColumn)
{
DebugCheck.NotNull(entityType);
DebugCheck.NotNull(properties);
DebugCheck.NotNull(entityTypeMappingFragment);
DebugCheck.NotNull(propertyPath);
var rootDeclaredProperties = entityType.GetRootType().DeclaredProperties;
foreach (var property in properties)
{
if (property.IsComplexType
&& propertyPath.Any(
p => p.IsComplexType
&& (p.ComplexType == property.ComplexType)))
{
throw Error.CircularComplexTypeHierarchy();
}
propertyPath.Add(property);
if (property.IsComplexType)
{
Generate(
entityType,
property.ComplexType.Properties,
entitySetMapping,
entityTypeMappingFragment,
propertyPath,
createNewColumn);
}
else
{
var tableColumn
= entitySetMapping.EntityTypeMappings
.SelectMany(etm => etm.MappingFragments)
.SelectMany(etmf => etmf.ColumnMappings)
.Where(pm => pm.PropertyPath.SequenceEqual(propertyPath))
.Select(pm => pm.ColumnProperty)
.FirstOrDefault();
if (tableColumn == null || createNewColumn)
{
var columnName
= string.Join("_", propertyPath.Select(p => p.Name));
tableColumn
= MapTableColumn(
property,
columnName,
!rootDeclaredProperties.Contains(propertyPath.First()));
entityTypeMappingFragment.Table.AddColumn(tableColumn);
if (entityType.KeyProperties().Contains(property))
{
entityTypeMappingFragment.Table.AddKeyMember(tableColumn);
}
}
entityTypeMappingFragment.AddColumnMapping(
new ColumnMappingBuilder(tableColumn, propertyPath.ToList()));
}
propertyPath.Remove(property);
}
}
private static IEnumerable<ColumnMappingBuilder> GetColumnMappings(
EntityType entityType, StorageEntitySetMapping entitySetMapping)
{
DebugCheck.NotNull(entityType);
DebugCheck.NotNull(entitySetMapping);
return new[] { entityType }
.Concat(GetParents(entityType))
.SelectMany(
et => entitySetMapping
.TypeMappings
.Where(stm => stm.Types.Contains(et))
.SelectMany(stm => stm.MappingFragments)
.SelectMany(mf => mf.ColumnMappings));
}
public static void GetIdentity_of_StorageSetMapping_returns_expected_value()
{
var entityType = new EntityType("ET", "N", DataSpace.CSpace);
var entitySet = new EntitySet("ES", "S", "T", null, entityType);
var associationType = new AssociationType("AT", "N", false, DataSpace.CSpace);
var associationSet = new AssociationSet("AS", associationType);
var entitySetMapping = new StorageEntitySetMapping(entitySet, null);
var associationSetMapping = new StorageAssociationSetMapping(associationSet, entitySet);
Assert.Equal(entitySet.Identity,
BaseMetadataMappingVisitor.IdentityHelper.GetIdentity(entitySetMapping));
Assert.Equal(associationSet.Identity,
BaseMetadataMappingVisitor.IdentityHelper.GetIdentity(associationSetMapping));
}
public void Can_get_modification_function_mappings()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entitySet = new EntitySet("S", "N", null, null, entityType);
var function = new EdmFunction(
"F", "N", DataSpace.CSpace,
new EdmFunctionPayload
{
IsFunctionImport = true
});
var container = new EntityContainer("C", DataSpace.CSpace);
container.AddEntitySetBase(entitySet);
container.AddFunctionImport(function);
var entitySetMapping =
new StorageEntitySetMapping(
entitySet,
new StorageEntityContainerMapping(container));
var functionMapping =
new StorageModificationFunctionMapping(
entitySet,
entityType,
function,
Enumerable.Empty<StorageModificationFunctionParameterBinding>(),
null,
null);
var entityFunctionMappings =
new StorageEntityTypeModificationFunctionMapping(entityType, functionMapping, null, null);
entitySetMapping.AddModificationFunctionMapping(entityFunctionMappings);
Assert.Same(entityFunctionMappings, entitySetMapping.ModificationFunctionMappings.Single());
}
public static StorageEntitySetMapping AddEntitySetMapping(
this DbDatabaseMapping databaseMapping, EntitySet entitySet)
{
DebugCheck.NotNull(databaseMapping);
DebugCheck.NotNull(entitySet);
var entitySetMapping = new StorageEntitySetMapping(entitySet, null);
databaseMapping
.EntityContainerMappings
.Single()
.AddEntitySetMapping(entitySetMapping);
return entitySetMapping;
}