public void Build_builds_valid_DbDatabaseMapping_for_entity_types() { var storeEntityType = EntityType.Create("foo_S", "bar_S", DataSpace.SSpace, null, null, null); var modelEntityType = EntityType.Create("foo_C", "bar_C", DataSpace.CSpace, null, null, null); var storeEntitySet = EntitySet.Create("ES_S", "Ns_S", null, null, storeEntityType, null); var storeContainer = EntityContainer.Create("C_S", DataSpace.SSpace, new[] { storeEntitySet }, null, null); var storeModel = EdmModel.CreateStoreModel(storeContainer, null, null); var modelEntitySet = EntitySet.Create("ES_C", "Ns_C", null, null, storeEntityType, null); var modelContainer = EntityContainer.Create("C_C", DataSpace.CSpace, new[] { modelEntitySet }, null, null); var mappingContext = new SimpleMappingContext(storeModel, true); mappingContext.AddMapping(storeContainer, modelContainer); mappingContext.AddMapping(storeEntitySet, modelEntitySet); mappingContext.AddMapping(storeEntityType, modelEntityType); var dbMapping = DbDatabaseMappingBuilder.Build(mappingContext).DatabaseMapping; Assert.Same(storeModel, dbMapping.Database); var entityContainerMapping = dbMapping.EntityContainerMappings.Single(); Assert.Same(storeContainer, entityContainerMapping.StorageEntityContainer); Assert.Same(modelContainer, entityContainerMapping.EdmEntityContainer); Assert.Equal(1, entityContainerMapping.EntitySetMappings.Count()); Assert.NotNull(dbMapping.Model); Assert.Same(modelContainer, dbMapping.Model.Containers.Single()); Assert.Same(modelEntityType, dbMapping.Model.EntityTypes.Single()); }
public void Build_builds_valid_DbDatabaseMapping_for_entity_types() { var storeEntityType = EntityType.Create("foo_S", "bar_S", DataSpace.SSpace, null, null, null); var modelEntityType = EntityType.Create("foo_C", "bar_C", DataSpace.CSpace, null, null, null); var storeEntitySet = EntitySet.Create("ES_S", "Ns_S", null, null, storeEntityType, null); var storeContainer = EntityContainer.Create("C_S", DataSpace.SSpace, new[] { storeEntitySet }, null, null); var storeModel = EdmModel.CreateStoreModel(storeContainer, null, null); var modelEntitySet = EntitySet.Create("ES_C", "Ns_C", null, null, storeEntityType, null); var modelContainer = EntityContainer.Create("C_C", DataSpace.CSpace, new[] { modelEntitySet }, null, null); var mappingContext = new SimpleMappingContext(storeModel, true); mappingContext.AddMapping(storeContainer, modelContainer); mappingContext.AddMapping(storeEntitySet, modelEntitySet); mappingContext.AddMapping(storeEntityType, modelEntityType); var dbMapping = DbDatabaseMappingBuilder.Build(mappingContext).DatabaseMapping; Assert.Same(storeModel, dbMapping.Database); var entityContainerMapping = dbMapping.EntityContainerMappings.Single(); Assert.Same(storeContainer, entityContainerMapping.StorageEntityContainer); Assert.Same(modelContainer, entityContainerMapping.EdmEntityContainer); Assert.Equal(1, entityContainerMapping.EntitySetMappings.Count()); Assert.NotNull(dbMapping.Model); Assert.Same(modelContainer, dbMapping.Model.Containers.Single()); Assert.Same(modelEntityType, dbMapping.Model.EntityTypes.Single()); }
public void BuildEntitySetMapping_creates_valid_entity_set_mapping() { var storeEntityType = EntityType.Create("foo_S", "bar_S", DataSpace.SSpace, null, null, null); var modelEntityType = EntityType.Create("foo_C", "bar_C", DataSpace.CSpace, null, null, null); var storeEntitySet = EntitySet.Create("ES_S", "Ns_S", null, null, storeEntityType, null); var storeContainer = EntityContainer.Create("C_S", DataSpace.SSpace, new[] { storeEntitySet }, null, null); var modelEntitySet = EntitySet.Create("ES_C", "Ns_C", null, null, storeEntityType, null); var modelContainer = EntityContainer.Create("C_C", DataSpace.SSpace, new[] { modelEntitySet }, null, null); var storageContainerMapping = new EntityContainerMapping(modelContainer, storeContainer, null, false, false); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(storeEntitySet, modelEntitySet); mappingContext.AddMapping(storeEntityType, modelEntityType); var entitySetMapping = DbDatabaseMappingBuilder.BuildEntitySetMappings(storageContainerMapping, mappingContext).Single(); Assert.Same(modelEntitySet, entitySetMapping.EntitySet); Assert.Equal(1, entitySetMapping.EntityTypeMappings.Count()); }
public void GenerateModel_genertes_model_and_sets_all_the_properties() { var mockModelGenerator = new Mock<ModelGenerator>(new ModelBuilderSettings(), "storeNamespace"); var storeModel = new EdmModel(DataSpace.SSpace); var mappingContext = new SimpleMappingContext(storeModel, true); mappingContext.AddMapping( storeModel.Containers.Single(), EntityContainer.Create("C", DataSpace.CSpace, null, null, null)); mockModelGenerator .Setup(g => g.CreateStoreModel()) .Returns(() => storeModel); mockModelGenerator .Setup(g => g.CreateMappingContext(It.Is<EdmModel>(model => model == storeModel))) .Returns(() => mappingContext); var errors = new List<EdmSchemaError>(); var databaseMapping = mockModelGenerator.Object.GenerateModel(errors).DatabaseMapping; Assert.Same(storeModel, databaseMapping.Database); Assert.NotNull(databaseMapping.Model); Assert.Equal(1, databaseMapping.EntityContainerMappings.Count); mockModelGenerator.Verify( g => g.CreateMappingContext(It.IsAny<EdmModel>()), Times.Once()); Assert.Empty(errors); }
// internal for testing internal static EdmProperty GenerateScalarProperty( SimpleMappingContext mappingContext, EdmProperty storeProperty, UniqueIdentifierService uniquePropertyNameService) { Debug.Assert(storeProperty != null, "storeProperty != null"); Debug.Assert(uniquePropertyNameService != null, "uniquePropertyNameService != null"); var conceptualPropertyName = CreateModelName(storeProperty.Name, uniquePropertyNameService); var conceptualProperty = EdmProperty.Create(conceptualPropertyName, storeProperty.TypeUsage.ModelTypeUsage); if (storeProperty.StoreGeneratedPattern != StoreGeneratedPattern.None) { conceptualProperty.SetMetadataProperties( new List <MetadataProperty> { CreateAnnotationMetadataProperty( "StoreGeneratedPattern", Enum.GetName( typeof(StoreGeneratedPattern), storeProperty.StoreGeneratedPattern)) }); } mappingContext.AddMapping(storeProperty, conceptualProperty); return(conceptualProperty); }
public void BuildEntityMapping_creates_valid_entity_mappings() { var storeEntityType = EntityType.Create( "foo_S", "bar_S", DataSpace.SSpace, new[] { "Id" }, new[] { CreateStoreProperty("Id", "int") }, null); var modelEntityType = EntityType.Create( "foo_C", "bar_C", DataSpace.CSpace, new[] { "C_Id" }, new[] { EdmProperty.CreatePrimitive("C_Id", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)) }, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(storeEntityType, modelEntityType); mappingContext.AddMapping(storeEntityType.Properties.Single(), modelEntityType.Properties.Single()); var modelEntitySet = EntitySet.Create("ES", "Ns", null, null, modelEntityType, null); var modelEntityContainer = EntityContainer.Create("C", DataSpace.SSpace, new[] { modelEntitySet }, null, null); var storeEntitySet = EntitySet.Create("ES", "Ns.Store", null, null, storeEntityType, null); var storageEntitySetMapping = new EntitySetMapping( modelEntitySet, new EntityContainerMapping(modelEntityContainer, null, null, false, false)); var typeMapping = DbDatabaseMappingBuilder .BuildEntityTypeMapping(storageEntitySetMapping, mappingContext, storeEntitySet); Assert.Same(modelEntityType, typeMapping.EntityType); Assert.Equal(1, typeMapping.MappingFragments.Count); var mappingFragment = typeMapping.MappingFragments.Single(); Assert.Equal(storeEntityType, mappingFragment.Table); Assert.Equal(1, mappingFragment.ColumnMappings.Count()); }
public void Can_add_and_get_property_mapping() { var p1 = EdmProperty.CreatePrimitive("p1", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)); var p2 = EdmProperty.CreatePrimitive("p2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(p1, p2); Assert.Same(p2, mappingContext[p1]); }
public void Can_add_and_get_property_mapping() { var p1 = EdmProperty.CreatePrimitive("p1", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)); var p2 = EdmProperty.CreatePrimitive("p2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(p1, p2); Assert.Same(p2, mappingContext[p1]); }
public void Can_add_and_get_entity_type_mapping() { var e1 = CreateEntityType("e1"); var e2 = CreateEntityType("e2"); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); Assert.Empty(mappingContext.ConceptualEntityTypes()); mappingContext.AddMapping(e1, e2); Assert.Same(e2, mappingContext[e1]); Assert.Same(e2, mappingContext.ConceptualEntityTypes().Single()); }
public void Can_add_and_get_association_type_mapping() { var at1 = AssociationType.Create("at1", "ns", false, DataSpace.CSpace, null, null, null, null); var at2 = AssociationType.Create("at2", "ns", false, DataSpace.CSpace, null, null, null, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(at1, at2); Assert.Same(at2, mappingContext[at1]); }
public void Removing_entity_set_mapping_removes_corresponding_entity_type() { var storeEntity = CreateEntityType("storeEntity"); var modelEntity = CreateEntityType("modelEntity"); var storeEntitySet = EntitySet.Create("storeEntitySet", null, null, null, storeEntity, null); var modelEntitySet = EntitySet.Create("modelEntitySet", null, null, null, modelEntity, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(storeEntity, modelEntity); mappingContext.AddMapping(storeEntitySet, modelEntitySet); Assert.Same(modelEntitySet, mappingContext.ConceptualEntitySets().Single()); Assert.Same(modelEntity, mappingContext.ConceptualEntityTypes().Single()); mappingContext.RemoveMapping(storeEntitySet); Assert.Empty(mappingContext.ConceptualEntitySets()); Assert.Empty(mappingContext.ConceptualEntityTypes()); }
private void GenerateAssociationSet( SimpleMappingContext mappingContext, AssociationSet storeAssociationSet, UniqueIdentifierService uniqueEntityContainerNames, UniqueIdentifierService globallyUniqueTypeNames) { // We will get a value when the same association type is used for multiple association sets. AssociationType conceptualAssociationType; if (!mappingContext.TryGetValue(storeAssociationSet.ElementType, out conceptualAssociationType)) { conceptualAssociationType = GenerateAssociationType( mappingContext, storeAssociationSet.ElementType, globallyUniqueTypeNames); } Debug.Assert(storeAssociationSet.AssociationSetEnds.Count == 2); var storeSetEnd0 = storeAssociationSet.AssociationSetEnds[0]; var storeSetEnd1 = storeAssociationSet.AssociationSetEnds[1]; EntitySet conceptualEntitySet0, conceptualEntitySet1; mappingContext.TryGetValue(storeSetEnd0.EntitySet, out conceptualEntitySet0); mappingContext.TryGetValue(storeSetEnd1.EntitySet, out conceptualEntitySet1); var conceptualAssociationSet = AssociationSet.Create( CreateModelName(storeAssociationSet.Name, uniqueEntityContainerNames), conceptualAssociationType, conceptualEntitySet0, conceptualEntitySet1, null); Debug.Assert(conceptualAssociationSet.AssociationSetEnds.Count == 2); var conceptualSetEnd0 = conceptualAssociationSet.AssociationSetEnds[0]; var conceptualSetEnd1 = conceptualAssociationSet.AssociationSetEnds[1]; mappingContext.AddMapping(storeAssociationSet, conceptualAssociationSet); mappingContext.AddMapping(storeSetEnd0, conceptualSetEnd0); mappingContext.AddMapping(storeSetEnd1, conceptualSetEnd1); }
public void Build_adds_association_types_to_model() { var storeEntityType = EntityType.Create("foo_S", "bar_S", DataSpace.SSpace, null, null, null); var storeEntitySet = EntitySet.Create("ES_S", "Ns_S", null, null, storeEntityType, null); var storeContainer = EntityContainer.Create("C_S", DataSpace.SSpace, new[] { storeEntitySet }, null, null); var storeModel = EdmModel.CreateStoreModel(storeContainer, null, null); var conceptualAssociationType = AssociationType.Create("AT_C", "ns", false, DataSpace.CSpace, null, null, null, null); var associationSet = AssociationSet.Create("AS_C", conceptualAssociationType, null, null, null); var modelContainer = EntityContainer.Create("C_C", DataSpace.CSpace, new[] { associationSet }, null, null); var mappingContext = new SimpleMappingContext(storeModel, true); mappingContext.AddMapping(storeContainer, modelContainer); mappingContext.AddMapping(new CollapsibleEntityAssociationSets(storeEntitySet), associationSet); var model = DbDatabaseMappingBuilder.Build(mappingContext); Assert.Same(conceptualAssociationType, model.ConceptualModel.AssociationTypes.SingleOrDefault()); }
public void Can_add_and_get_entity_type_mapping() { var e1 = CreateEntityType("e1"); var e2 = CreateEntityType("e2"); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); Assert.Empty(mappingContext.ConceptualEntityTypes()); mappingContext.AddMapping(e1, e2); Assert.Same(e2, mappingContext[e1]); Assert.Same(e2, mappingContext.ConceptualEntityTypes().Single()); }
public void Can_add_and_get_entity_container_mapping() { var es1 = EntitySet.Create("es1", null, null, null, CreateEntityType("e"), null); var ec1 = EntityContainer.Create("ec1", DataSpace.CSpace, new[] { es1 }, null, null); var es2 = EntitySet.Create("es1", null, null, null, CreateEntityType("e"), null); var ec2 = EntityContainer.Create("ec2", DataSpace.CSpace, new[] { es2 }, null, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(ec1, ec2); Assert.Same(ec2, mappingContext[ec1]); }
public void Build_adds_association_types_to_model() { var storeEntityType = EntityType.Create("foo_S", "bar_S", DataSpace.SSpace, null, null, null); var storeEntitySet = EntitySet.Create("ES_S", "Ns_S", null, null, storeEntityType, null); var storeContainer = EntityContainer.Create("C_S", DataSpace.SSpace, new[] { storeEntitySet }, null, null); var storeModel = EdmModel.CreateStoreModel(storeContainer, null, null); var conceptualAssociationType = AssociationType.Create("AT_C", "ns", false, DataSpace.CSpace, null, null, null, null); var associationSet = AssociationSet.Create("AS_C", conceptualAssociationType, null, null, null); var modelContainer = EntityContainer.Create("C_C", DataSpace.CSpace, new[] { associationSet }, null, null); var mappingContext = new SimpleMappingContext(storeModel, true); mappingContext.AddMapping(storeContainer, modelContainer); mappingContext.AddMapping(new CollapsibleEntityAssociationSets(storeEntitySet), associationSet); var model = DbDatabaseMappingBuilder.Build(mappingContext); Assert.Same(conceptualAssociationType, model.ConceptualModel.AssociationTypes.SingleOrDefault()); }
public void Can_add_and_get_function_mapping() { var storeFunction = EdmFunction.Create("fs", "ns", DataSpace.SSpace, new EdmFunctionPayload(), null); var functionImport = EdmFunction.Create("fs", "ns", DataSpace.SSpace, new EdmFunctionPayload(), null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); Assert.Empty(mappingContext.MappedStoreFunctions()); mappingContext.AddMapping(storeFunction, functionImport); Assert.Same(functionImport, mappingContext[storeFunction]); Assert.Same(storeFunction, mappingContext.MappedStoreFunctions().Single()); }
public void Can_add_and_get_association_end_member_mapping() { var et1 = CreateEntityType("et1"); var et2 = CreateEntityType("et2"); var aem1 = AssociationEndMember.Create("aem1", et1.GetReferenceType(), RelationshipMultiplicity.One, OperationAction.None, null); var aem2 = AssociationEndMember.Create("aem2", et2.GetReferenceType(), RelationshipMultiplicity.One, OperationAction.None, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(aem1, aem2); Assert.Same(aem2, mappingContext[aem1]); }
public void Can_add_and_get_entity_container_mapping() { var es1 = EntitySet.Create("es1", null, null, null, CreateEntityType("e"), null); var ec1 = EntityContainer.Create("ec1", DataSpace.CSpace, new[] { es1 }, null, null); var es2 = EntitySet.Create("es1", null, null, null, CreateEntityType("e"), null); var ec2 = EntityContainer.Create("ec2", DataSpace.CSpace, new[] { es2 }, null, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(ec1, ec2); Assert.Same(ec2, mappingContext[ec1]); }
public void Can_add_and_get_mapping_for_collapsed_entity_sets() { var storeEntity = CreateEntityType("storeEntity"); var storeEntitySet = EntitySet.Create("storeEntitySet", null, null, null, storeEntity, null); var collapsibleAssociationSet = new CollapsibleEntityAssociationSets(storeEntitySet); var associationType = AssociationType.Create("modelAssociationType", "ns", false, DataSpace.CSpace, null, null, null, null); var associationSet = AssociationSet.Create("modelAssociationType", associationType, null, null, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(collapsibleAssociationSet, associationSet); Assert.Same(associationSet, mappingContext[collapsibleAssociationSet]); }
public void ConceptualAssociationSets_returns_associationsets_for_collapsed_entity_sets() { var storeEntity = CreateEntityType("storeEntity"); var storeEntitySet = EntitySet.Create("storeEntitySet", null, null, null, storeEntity, null); var collapsibleAssociationSet = new CollapsibleEntityAssociationSets(storeEntitySet); var associationType = AssociationType.Create("modelAssociationType", "ns", false, DataSpace.CSpace, null, null, null, null); var associationSet = AssociationSet.Create("modelAssociationType", associationType, null, null, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); Assert.Empty(mappingContext.ConceptualAssociationSets()); mappingContext.AddMapping(collapsibleAssociationSet, associationSet); Assert.Equal(1, mappingContext.ConceptualAssociationSets().Count()); Assert.Same(associationSet, mappingContext.ConceptualAssociationSets().Single()); }
private AssociationType GenerateAssociationType( SimpleMappingContext mappingContext, AssociationType storeAssociationType, UniqueIdentifierService globallyUniqueTypeNames) { Debug.Assert(storeAssociationType.RelationshipEndMembers.Count == 2); var storeEndMember0 = (AssociationEndMember)storeAssociationType.RelationshipEndMembers[0]; var storeEndMember1 = (AssociationEndMember)storeAssociationType.RelationshipEndMembers[1]; var storeSchemaVersion = EntityFrameworkVersion.DoubleToVersion(mappingContext.StoreModel.SchemaVersion); var isFkAssociation = storeSchemaVersion > EntityFrameworkVersion.Version1 && (_generateForeignKeyProperties || RequiresReferentialConstraint(storeAssociationType)); var uniqueEndMemberNames = new UniqueIdentifierService(StringComparer.OrdinalIgnoreCase); var multiplicityOverride = GetMultiplicityOverride(storeAssociationType); var conceptualEndMember0 = GenerateAssociationEndMember( mappingContext, storeEndMember0, uniqueEndMemberNames, multiplicityOverride); var conceptualEndMember1 = GenerateAssociationEndMember( mappingContext, storeEndMember1, uniqueEndMemberNames, multiplicityOverride); var conceptualAssociationType = AssociationType.Create( CreateModelName(storeAssociationType.Name, globallyUniqueTypeNames), _namespaceName, isFkAssociation, DataSpace.CSpace, conceptualEndMember0, conceptualEndMember1, CreateReferentialConstraint(mappingContext, storeAssociationType), null); CreateModelNavigationProperties(conceptualAssociationType); mappingContext.AddMapping(storeAssociationType, conceptualAssociationType); return(conceptualAssociationType); }
public void Can_add_and_get_entity_set_mapping() { var dummy = CreateEntityType("e"); var es1 = EntitySet.Create("es1", null, null, null, dummy, null); var es2 = EntitySet.Create("es2", null, null, null, dummy, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(es1, es2); Assert.Same(es2, mappingContext[es1]); EntitySet outEntitySet; Assert.True(mappingContext.TryGetValue(es1, out outEntitySet)); Assert.Same(es2, outEntitySet); Assert.False(mappingContext.TryGetValue(es2, out outEntitySet)); Assert.Null(outEntitySet); }
public void Can_add_and_get_entity_set_mapping() { var dummy = CreateEntityType("e"); var es1 = EntitySet.Create("es1", null, null, null, dummy, null); var es2 = EntitySet.Create("es2", null, null, null, dummy, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(es1, es2); Assert.Same(es2, mappingContext[es1]); EntitySet outEntitySet; Assert.True(mappingContext.TryGetValue(es1, out outEntitySet)); Assert.Same(es2, outEntitySet); Assert.False(mappingContext.TryGetValue(es2, out outEntitySet)); Assert.Null(outEntitySet); }
// internal for testing internal EntityType GenerateEntityType( SimpleMappingContext mappingContext, EntityType storeEntityType, UniqueIdentifierService globallyUniqueTypeNames) { Debug.Assert(mappingContext != null, "mappingContext != null"); Debug.Assert(storeEntityType != null, "storeEntityType != null"); Debug.Assert(globallyUniqueTypeNames != null, "globallyUniqueTypeNames != null"); var conceptualEntityTypeName = CreateModelName( (_pluralizationService != null) ? _pluralizationService.Singularize(storeEntityType.Name) : storeEntityType.Name, globallyUniqueTypeNames); var uniquePropertyNameService = new UniqueIdentifierService(); uniquePropertyNameService.AdjustIdentifier(conceptualEntityTypeName); var edmMembers = new List <EdmMember>(); var keyMemberNames = new List <string>(); foreach (var storeProperty in storeEntityType.Properties) { // cannot skip this even if the store property is foreign key and generating foreign keys is disabled // since it creates property mappings the will be used when mapping association types. var conceptualProperty = GenerateScalarProperty(mappingContext, storeProperty, uniquePropertyNameService); if (_generateForeignKeyProperties || !mappingContext.StoreForeignKeyProperties.Contains(storeProperty) || storeEntityType.KeyMembers.Contains(storeProperty)) { edmMembers.Add(conceptualProperty); if (storeEntityType.KeyMembers.Contains(storeProperty)) { keyMemberNames.Add(conceptualProperty.Name); } } } var conceptualEntity = EntityType.Create( conceptualEntityTypeName, _namespaceName, DataSpace.CSpace, keyMemberNames, edmMembers, null); mappingContext.AddMapping(storeEntityType, conceptualEntity); return(conceptualEntity); }
public void Can_add_get_association_set_mapping() { var storeAssociationSet = AssociationSet.Create( "storeAssociationSet", AssociationType.Create("storeAssociationType", "ns.Store", false, DataSpace.SSpace, null, null, null, null), null, null, null); var conceptualAssociationSet = AssociationSet.Create( "conceptualAssociationSet", AssociationType.Create("conceptualAssociationType", "ns", false, DataSpace.CSpace, null, null, null, null), null, null, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(storeAssociationSet, conceptualAssociationSet); Assert.Same(conceptualAssociationSet, mappingContext[storeAssociationSet]); }
// internal for testing internal IEnumerable <EdmFunction> GenerateFunctions( SimpleMappingContext mappingContext, EdmModel storeModel, UniqueIdentifierService uniqueEntityContainerNames, UniqueIdentifierService globallyUniqueTypeNames) { Debug.Assert(mappingContext != null, "mappingContext != null"); Debug.Assert(storeModel != null, "storeModel != null"); Debug.Assert(uniqueEntityContainerNames != null, "uniqueEntityContainerNames != null"); Debug.Assert(globallyUniqueTypeNames != null, "globallyUniqueTypeNames != null"); // TODO: Note we import only TVFs here and other store functions are // imported elsewhere - ideally we import all functions in one place // http://entityframework.codeplex.com/workitem/925 if (EntityFrameworkVersion.DoubleToVersion(storeModel.SchemaVersion) < EntityFrameworkVersion.Version3) { yield break; } foreach (var storeFunction in storeModel.Functions) { if (storeFunction.IsComposableAttribute && !storeFunction.AggregateAttribute && storeFunction.Parameters.All(p => p.Mode == ParameterMode.In)) { var functionImport = GenerateFunction( mappingContext, storeFunction, uniqueEntityContainerNames, globallyUniqueTypeNames); if (functionImport != null) { mappingContext.AddMapping(storeFunction, functionImport); yield return(functionImport); } } } }
// internal for testing internal void GenerateEntitySet( SimpleMappingContext mappingContext, EntitySet storeEntitySet, UniqueIdentifierService uniqueEntityContainerNames, UniqueIdentifierService globallyUniqueTypeNames) { Debug.Assert(mappingContext != null, "mappingContext != null"); Debug.Assert(storeEntitySet != null, "storeEntitySet != null"); Debug.Assert(uniqueEntityContainerNames != null, "uniqueEntityContainerNames != null"); Debug.Assert(globallyUniqueTypeNames != null, "globallyUniqueTypeNames != null"); var conceptualEntityType = GenerateEntityType(mappingContext, storeEntitySet.ElementType, globallyUniqueTypeNames); var conceptualEntitySetName = CreateModelName( (_pluralizationService != null) ? _pluralizationService.Pluralize(storeEntitySet.Name) : storeEntitySet.Name, uniqueEntityContainerNames); var conceptualEntitySet = EntitySet.Create(conceptualEntitySetName, null, null, null, conceptualEntityType, null); mappingContext.AddMapping(storeEntitySet, conceptualEntitySet); }
private static AssociationEndMember GenerateAssociationEndMember( SimpleMappingContext mappingContext, AssociationEndMember storeEndMember, UniqueIdentifierService uniqueEndMemberNames, RelationshipMultiplicity multiplicity, OperationAction deleteBehavior) { var storeEntityType = ((EntityType)((RefType)storeEndMember.TypeUsage.EdmType).ElementType); var conceptualEntityType = mappingContext[storeEntityType]; var conceptualEndMember = AssociationEndMember.Create( CreateModelName(storeEndMember.Name, uniqueEndMemberNames), conceptualEntityType.GetReferenceType(), multiplicity, deleteBehavior, null); mappingContext.AddMapping(storeEndMember, conceptualEndMember); return(conceptualEndMember); }
public void Can_add_and_get_association_set_end_mapping() { var et1 = CreateEntityType("et1"); var et2 = CreateEntityType("et2"); var es1 = EntitySet.Create("es1", null, null, null, et1, null); var es2 = EntitySet.Create("es2", null, null, null, et2, null); var aem1 = AssociationEndMember.Create("aem1", et1.GetReferenceType(), RelationshipMultiplicity.One, OperationAction.None, null); var aem2 = AssociationEndMember.Create("aem2", et2.GetReferenceType(), RelationshipMultiplicity.One, OperationAction.None, null); var at1 = AssociationType.Create("at1", "ns", false, DataSpace.CSpace, aem1, aem2, null, null); var as1 = AssociationSet.Create("as1", at1, es1, es2, null); Assert.Equal(2, as1.AssociationSetEnds.Count); var ase1 = as1.AssociationSetEnds[0]; var ase2 = as1.AssociationSetEnds[1]; var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(ase1, ase2); Assert.Same(ase2, mappingContext[ase1]); }
public void Can_add_get_association_type_mapping() { var storeAssociationType = AssociationType.Create("storeAssociationType", "ns.Store", false, DataSpace.SSpace, null, null, null, null); var conceptualAssociationType = AssociationType.Create("conceptualAssociationType", "ns", false, DataSpace.CSpace, null, null, null, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(storeAssociationType, conceptualAssociationType); Assert.Same(conceptualAssociationType, mappingContext[storeAssociationType]); AssociationType outAssociationType; Assert.True(mappingContext.TryGetValue(storeAssociationType, out outAssociationType)); Assert.Same(conceptualAssociationType, outAssociationType); Assert.False(mappingContext.TryGetValue(conceptualAssociationType, out outAssociationType)); Assert.Null(outAssociationType); }
public void BuildPropertyMapping_does_not_build_property_mappings_for_foreign_key_properties_if_foreign_keys_disabled() { var storeEntityType = EntityType.Create( "foo", "bar", DataSpace.SSpace, new[] { "Id" }, new[] { CreateStoreProperty("Id", "int"), CreateStoreProperty("ForeignKey", "int"), }, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), false); mappingContext.StoreForeignKeyProperties.Add(storeEntityType.Properties.Single(p => p.Name == "ForeignKey")); foreach (var storeProperty in storeEntityType.Properties) { mappingContext.AddMapping( storeProperty, EdmProperty.CreatePrimitive( storeProperty.Name + "Model", (PrimitiveType)storeProperty.TypeUsage.EdmType)); } var propertyMappings = DbDatabaseMappingBuilder .BuildPropertyMapping(storeEntityType, mappingContext); Assert.Equal( new[] { "Id" }, propertyMappings.Select(m => m.ColumnProperty.Name)); Assert.Equal( new[] { "IdModel" }, propertyMappings.SelectMany(m => m.PropertyPath, (m, p) => p.Name)); }
public void BuildPropertyMapping_creates_valid_property_mappings() { var storeEntityType = EntityType.Create( "foo", "bar", DataSpace.SSpace, new[] { "Id" }, new[] { CreateStoreProperty("Id", "int"), CreateStoreProperty("FirstName", "nvarchar"), CreateStoreProperty("LastName", "char") }, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); foreach (var storeProperty in storeEntityType.Properties) { mappingContext.AddMapping( storeProperty, EdmProperty.CreatePrimitive( storeProperty.Name + "Model", (PrimitiveType)storeProperty.TypeUsage.EdmType)); } var propertyMappings = DbDatabaseMappingBuilder .BuildPropertyMapping(storeEntityType, mappingContext); Assert.Equal( new[] { "Id", "FirstName", "LastName" }, propertyMappings.Select(m => m.ColumnProperty.Name)); Assert.Equal( new[] { "IdModel", "FirstNameModel", "LastNameModel" }, propertyMappings.SelectMany(m => m.PropertyPath, (m, p) => p.Name)); }
public SimpleMappingContext Build(EdmModel storeModel) { Debug.Assert(storeModel != null, "storeModel != null"); var mappingContext = new SimpleMappingContext(storeModel, _generateForeignKeyProperties); var uniqueEntityContainerNames = new UniqueIdentifierService(); var globallyUniqueTypeNames = new UniqueIdentifierService(); CollectForeignKeyProperties(mappingContext, storeModel); foreach (var storeEntitySet in storeModel.Containers.Single().EntitySets) { GenerateEntitySet(mappingContext, storeEntitySet, uniqueEntityContainerNames, globallyUniqueTypeNames); } GenerateAssociationSets( mappingContext, uniqueEntityContainerNames, globallyUniqueTypeNames); var functionImports = GenerateFunctions(mappingContext, storeModel, uniqueEntityContainerNames, globallyUniqueTypeNames) .ToArray(); var conceptualModelContainer = EntityContainer.Create( _containerName, DataSpace.CSpace, mappingContext.ConceptualEntitySets() .Concat(mappingContext.ConceptualAssociationSets().Cast <EntitySetBase>()), functionImports, EntityFrameworkVersion.DoubleToVersion(storeModel.SchemaVersion) >= EntityFrameworkVersion.Version2 ? new[] { CreateAnnotationMetadataProperty("LazyLoadingEnabled", "true") } : null); mappingContext.AddMapping(storeModel.Containers.Single(), conceptualModelContainer); return(mappingContext); }
public SimpleMappingContext Build(EdmModel storeModel) { Debug.Assert(storeModel != null, "storeModel != null"); var mappingContext = new SimpleMappingContext(storeModel, _generateForeignKeyProperties); var uniqueEntityContainerNames = new UniqueIdentifierService(); var globallyUniqueTypeNames = new UniqueIdentifierService(); CollectForeignKeyProperties(mappingContext, storeModel); foreach (var storeEntitySet in storeModel.Containers.Single().EntitySets) { GenerateEntitySet(mappingContext, storeEntitySet, uniqueEntityContainerNames, globallyUniqueTypeNames); } GenerateAssociationSets( mappingContext, uniqueEntityContainerNames, globallyUniqueTypeNames); var functionImports = GenerateFunctions(mappingContext, storeModel, uniqueEntityContainerNames, globallyUniqueTypeNames) .ToArray(); var conceptualModelContainer = EntityContainer.Create( _containerName, DataSpace.CSpace, mappingContext.ConceptualEntitySets() .Concat(mappingContext.ConceptualAssociationSets().Cast<EntitySetBase>()), functionImports, EntityFrameworkVersion.DoubleToVersion(storeModel.SchemaVersion) >= EntityFrameworkVersion.Version2 ? new[] { CreateAnnotationMetadataProperty("LazyLoadingEnabled", "true") } : null); mappingContext.AddMapping(storeModel.Containers.Single(), conceptualModelContainer); return mappingContext; }
public void Build_does_not_try_map_not_mapped_functions() { var rowTypeProperty = CreateStoreProperty("p1", "int"); var storeFunction = EdmFunction.Create( "f_s", "storeModel", DataSpace.SSpace, new EdmFunctionPayload { IsComposable = true, IsFunctionImport = false, ReturnParameters = new[] { FunctionParameter.Create( "ReturnType", RowType.Create(new[] { rowTypeProperty }, null).GetCollectionType(), ParameterMode.ReturnValue) } }, null); var modelContainer = EntityContainer.Create("C_C", DataSpace.CSpace, new EntitySet[0], null, null); var storeContainer = EntityContainer.Create("C_S", DataSpace.SSpace, new EntitySet[0], null, null); var storeModel = EdmModel.CreateStoreModel(storeContainer, null, null); storeModel.AddItem(storeFunction); var mappingContext = new SimpleMappingContext(storeModel, true); mappingContext.AddMapping(storeContainer, modelContainer); var entityModel = DbDatabaseMappingBuilder.Build(mappingContext).ConceptualModel; Assert.NotNull(entityModel); Assert.Empty(entityModel.Containers.Single().FunctionImports); }
private static SimpleMappingContext CreateSimpleMappingContext(bool isForeignKey) { var int32TypeUsage = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)); var storeP1 = new[] { CreateStoreProperty("storeSourceId", "int") }; var storeP2 = new[] { CreateStoreProperty("storeTargetId", "int") }; var modelP1 = new[] { EdmProperty.Create("modelSourceId", int32TypeUsage) }; var modelP2 = new[] { EdmProperty.Create("modelTargetId", int32TypeUsage) }; var storeET1 = EntityType.Create("storeET1", "N", DataSpace.SSpace, new[] { "storeSourceId" }, storeP1, null); var storeET2 = EntityType.Create("storeET2", "N", DataSpace.SSpace, new[] { "storeTargetId" }, storeP2, null); var modelET1 = EntityType.Create("modelET1", "N", DataSpace.CSpace, new[] { "modelSourceId" }, modelP1, null); var modelET2 = EntityType.Create("modelET2", "N", DataSpace.CSpace, new[] { "modelTargetId" }, modelP2, null); var storeES1 = EntitySet.Create("storeES1", null, null, null, storeET1, null); var storeES2 = EntitySet.Create("storeES2", null, null, null, storeET2, null); var modelES1 = EntitySet.Create("modelES1", null, null, null, modelET1, null); var modelES2 = EntitySet.Create("modelES2", null, null, null, modelET2, null); var storeEM1 = AssociationEndMember.Create( "storeEM1", storeET1.GetReferenceType(), RelationshipMultiplicity.One, OperationAction.None, null); var storeEM2 = AssociationEndMember.Create( "storeEM2", storeET2.GetReferenceType(), RelationshipMultiplicity.One, OperationAction.None, null); var modelEM1 = AssociationEndMember.Create( "modelEM1", modelET1.GetReferenceType(), RelationshipMultiplicity.Many, OperationAction.None, null); var modelEM2 = AssociationEndMember.Create( "modelEM2", modelET2.GetReferenceType(), RelationshipMultiplicity.Many, OperationAction.None, null); var storeRC = new ReferentialConstraint(storeEM1, storeEM2, storeP1, storeP2); var modelRC = new ReferentialConstraint(modelEM1, modelEM2, modelP1, modelP2); var storeAT = AssociationType.Create("storeAT", "N", isForeignKey, DataSpace.SSpace, storeEM1, storeEM2, storeRC, null); var modelAT = AssociationType.Create("modelAT", "N", isForeignKey, DataSpace.CSpace, modelEM1, modelEM2, modelRC, null); var storeAS = AssociationSet.Create("storeAS", storeAT, storeES1, storeES2, null); var modelAS = AssociationSet.Create("modelAS", modelAT, modelES1, modelES2, null); var storeContainer = EntityContainer.Create( "storeContainer", DataSpace.SSpace, new EntitySetBase[] { storeES1, storeES2, storeAS }, null, null); var modelContainer = EntityContainer.Create( "modelContainer", DataSpace.CSpace, new EntitySetBase[] { modelES1, modelES2, modelAS }, null, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(storeP1[0], modelP1[0]); mappingContext.AddMapping(storeP2[0], modelP2[0]); mappingContext.AddMapping(storeET1, modelET1); mappingContext.AddMapping(storeET2, modelET2); mappingContext.AddMapping(storeES1, modelES1); mappingContext.AddMapping(storeES2, modelES2); mappingContext.AddMapping(storeEM1, modelEM1); mappingContext.AddMapping(storeEM2, modelEM2); mappingContext.AddMapping(storeAT, modelAT); mappingContext.AddMapping(storeAS, modelAS); mappingContext.AddMapping(storeAS.AssociationSetEnds[0], modelAS.AssociationSetEnds[0]); mappingContext.AddMapping(storeAS.AssociationSetEnds[1], modelAS.AssociationSetEnds[1]); mappingContext.AddMapping(storeContainer, modelContainer); return mappingContext; }
public void BuildPropertyMapping_creates_valid_property_mappings() { var storeEntityType = EntityType.Create( "foo", "bar", DataSpace.SSpace, new[] { "Id" }, new[] { CreateStoreProperty("Id", "int"), CreateStoreProperty("FirstName", "nvarchar"), CreateStoreProperty("LastName", "char") }, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); foreach (var storeProperty in storeEntityType.Properties) { mappingContext.AddMapping( storeProperty, EdmProperty.CreatePrimitive( storeProperty.Name + "Model", (PrimitiveType)storeProperty.TypeUsage.EdmType)); } var propertyMappings = DbDatabaseMappingBuilder .BuildPropertyMapping(storeEntityType, mappingContext); Assert.Equal( new[] { "Id", "FirstName", "LastName" }, propertyMappings.Select(m => m.ColumnProperty.Name)); Assert.Equal( new[] { "IdModel", "FirstNameModel", "LastNameModel" }, propertyMappings.SelectMany(m => m.PropertyPath, (m, p) => p.Name)); }
BuildPropertyMapping_builds_property_mappings_for_foreign_key_properties_which_are_primary_keys_even_if_foreign_keys_disabled() { var storeEntityType = EntityType.Create( "foo", "bar", DataSpace.SSpace, new[] { "IdAndForeignKey" }, new[] { CreateStoreProperty("IdAndForeignKey", "int"), }, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), false); mappingContext.StoreForeignKeyProperties.Add(storeEntityType.Properties.Single(p => p.Name == "IdAndForeignKey")); foreach (var storeProperty in storeEntityType.Properties) { mappingContext.AddMapping( storeProperty, EdmProperty.CreatePrimitive( storeProperty.Name + "Model", (PrimitiveType)storeProperty.TypeUsage.EdmType)); } var propertyMappings = DbDatabaseMappingBuilder .BuildPropertyMapping(storeEntityType, mappingContext); Assert.Equal( new[] { "IdAndForeignKey" }, propertyMappings.Select(m => m.ColumnProperty.Name)); Assert.Equal( new[] { "IdAndForeignKeyModel" }, propertyMappings.SelectMany(m => m.PropertyPath, (m, p) => p.Name)); }
public void Can_add_and_get_mapping_for_collapsed_entity_sets() { var storeEntity = CreateEntityType("storeEntity"); var storeEntitySet = EntitySet.Create("storeEntitySet", null, null, null, storeEntity, null); var collapsibleAssociationSet = new CollapsibleEntityAssociationSets(storeEntitySet); var associationType = AssociationType.Create("modelAssociationType", "ns", false, DataSpace.CSpace, null, null, null, null); var associationSet = AssociationSet.Create("modelAssociationType", associationType, null, null, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(collapsibleAssociationSet, associationSet); Assert.Same(associationSet, mappingContext[collapsibleAssociationSet]); }
// internal for testing internal void GenerateEntitySet( SimpleMappingContext mappingContext, EntitySet storeEntitySet, UniqueIdentifierService uniqueEntityContainerNames, UniqueIdentifierService globallyUniqueTypeNames) { Debug.Assert(mappingContext != null, "mappingContext != null"); Debug.Assert(storeEntitySet != null, "storeEntitySet != null"); Debug.Assert(uniqueEntityContainerNames != null, "uniqueEntityContainerNames != null"); Debug.Assert(globallyUniqueTypeNames != null, "globallyUniqueTypeNames != null"); var conceptualEntityType = GenerateEntityType(mappingContext, storeEntitySet.ElementType, globallyUniqueTypeNames); var conceptualEntitySetName = CreateModelName( (_pluralizationService != null) ? _pluralizationService.Pluralize(storeEntitySet.Name) : storeEntitySet.Name, uniqueEntityContainerNames); var conceptualEntitySet = EntitySet.Create(conceptualEntitySetName, null, null, null, conceptualEntityType, null); mappingContext.AddMapping(storeEntitySet, conceptualEntitySet); }
public void Build_does_not_try_map_not_mapped_functions() { var rowTypeProperty = CreateStoreProperty("p1", "int"); var storeFunction = EdmFunction.Create( "f_s", "storeModel", DataSpace.SSpace, new EdmFunctionPayload { IsComposable = true, IsFunctionImport = false, ReturnParameters = new[] { FunctionParameter.Create( "ReturnType", RowType.Create(new[] { rowTypeProperty }, null).GetCollectionType(), ParameterMode.ReturnValue) } }, null); var modelContainer = EntityContainer.Create("C_C", DataSpace.CSpace, new EntitySet[0], null, null); var storeContainer = EntityContainer.Create("C_S", DataSpace.SSpace, new EntitySet[0], null, null); var storeModel = EdmModel.CreateStoreModel(storeContainer, null, null); storeModel.AddItem(storeFunction); var mappingContext = new SimpleMappingContext(storeModel, true); mappingContext.AddMapping(storeContainer, modelContainer); var entityModel = DbDatabaseMappingBuilder.Build(mappingContext).ConceptualModel; Assert.NotNull(entityModel); Assert.Empty(entityModel.Containers.Single().FunctionImports); }
public void BuildEntityMapping_creates_valid_entity_mappings() { var storeEntityType = EntityType.Create( "foo_S", "bar_S", DataSpace.SSpace, new[] { "Id" }, new[] { CreateStoreProperty("Id", "int") }, null); var modelEntityType = EntityType.Create( "foo_C", "bar_C", DataSpace.CSpace, new[] { "C_Id" }, new[] { EdmProperty.CreatePrimitive("C_Id", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)) }, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(storeEntityType, modelEntityType); mappingContext.AddMapping(storeEntityType.Properties.Single(), modelEntityType.Properties.Single()); var modelEntitySet = EntitySet.Create("ES", "Ns", null, null, modelEntityType, null); var modelEntityContainer = EntityContainer.Create("C", DataSpace.SSpace, new[] { modelEntitySet }, null, null); var storeEntitySet = EntitySet.Create("ES", "Ns.Store", null, null, storeEntityType, null); var storageEntitySetMapping = new EntitySetMapping( modelEntitySet, new EntityContainerMapping(modelEntityContainer, null, null, false, false)); var typeMapping = DbDatabaseMappingBuilder .BuildEntityTypeMapping(storageEntitySetMapping, mappingContext, storeEntitySet); Assert.Same(modelEntityType, typeMapping.EntityType); Assert.Equal(1, typeMapping.MappingFragments.Count); var mappingFragment = typeMapping.MappingFragments.Single(); Assert.Equal(storeEntityType, mappingFragment.Table); Assert.Equal(1, mappingFragment.ColumnMappings.Count()); }
public void GenerateModel_combines_store_model_and_mapping_errors() { var storeModelError = new EdmSchemaError("storeError", 42, EdmSchemaErrorSeverity.Error); var errorMetadataProperty = MetadataProperty.Create( MetadataItemHelper.SchemaErrorsMetadataPropertyName, TypeUsage.CreateDefaultTypeUsage( PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String).GetCollectionType()), new List<EdmSchemaError> { storeModelError }); var entityType = EntityType.Create( "foo", "bar", DataSpace.SSpace, new string[0], new EdmMember[0], new[] { errorMetadataProperty }); var storeModel = new EdmModel(DataSpace.SSpace); storeModel.AddItem(entityType); var mappingContext = new SimpleMappingContext(storeModel, true); mappingContext.AddMapping( storeModel.Containers.Single(), EntityContainer.Create("C", DataSpace.CSpace, null, null, null)); mappingContext.Errors.Add(new EdmSchemaError("mappingError", 911, EdmSchemaErrorSeverity.Warning)); var mockModelGenerator = new Mock<ModelGenerator>(new ModelBuilderSettings(), "storeNamespace"); mockModelGenerator .Setup(g => g.CreateStoreModel()) .Returns(() => storeModel); mockModelGenerator .Setup(g => g.CreateMappingContext(It.IsAny<EdmModel>())) .Returns(() => mappingContext); var errors = new List<EdmSchemaError>(); mockModelGenerator.Object.GenerateModel(errors); Assert.Equal(new[] { storeModelError, mappingContext.Errors.Single() }, errors); }
// internal for testing internal IEnumerable<EdmFunction> GenerateFunctions( SimpleMappingContext mappingContext, EdmModel storeModel, UniqueIdentifierService uniqueEntityContainerNames, UniqueIdentifierService globallyUniqueTypeNames) { Debug.Assert(mappingContext != null, "mappingContext != null"); Debug.Assert(storeModel != null, "storeModel != null"); Debug.Assert(uniqueEntityContainerNames != null, "uniqueEntityContainerNames != null"); Debug.Assert(globallyUniqueTypeNames != null, "globallyUniqueTypeNames != null"); // TODO: Note we import only TVFs here and other store functions are // imported elsewhere - ideally we import all functions in one place // http://entityframework.codeplex.com/workitem/925 if (EntityFrameworkVersion.DoubleToVersion(storeModel.SchemaVersion) < EntityFrameworkVersion.Version3) { yield break; } foreach (var storeFunction in storeModel.Functions) { if (storeFunction.IsComposableAttribute && !storeFunction.AggregateAttribute && storeFunction.Parameters.All(p => p.Mode == ParameterMode.In)) { var functionImport = GenerateFunction( mappingContext, storeFunction, uniqueEntityContainerNames, globallyUniqueTypeNames); if (functionImport != null) { mappingContext.AddMapping(storeFunction, functionImport); yield return functionImport; } } } }
public void Can_add_and_get_association_type_mapping() { var at1 = AssociationType.Create("at1", "ns", false, DataSpace.CSpace, null, null, null, null); var at2 = AssociationType.Create("at2", "ns", false, DataSpace.CSpace, null, null, null, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(at1, at2); Assert.Same(at2, mappingContext[at1]); }
public void Can_add_get_association_set_mapping() { var storeAssociationSet = AssociationSet.Create( "storeAssociationSet", AssociationType.Create("storeAssociationType", "ns.Store", false, DataSpace.SSpace, null, null, null, null), null, null, null); var conceptualAssociationSet = AssociationSet.Create( "conceptualAssociationSet", AssociationType.Create("conceptualAssociationType", "ns", false, DataSpace.CSpace, null, null, null, null), null, null, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(storeAssociationSet, conceptualAssociationSet); Assert.Same(conceptualAssociationSet, mappingContext[storeAssociationSet]); }
public void Can_add_and_get_function_mapping() { var storeFunction = EdmFunction.Create("fs", "ns", DataSpace.SSpace, new EdmFunctionPayload(), null); var functionImport = EdmFunction.Create("fs", "ns", DataSpace.SSpace, new EdmFunctionPayload(), null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); Assert.Empty(mappingContext.MappedStoreFunctions()); mappingContext.AddMapping(storeFunction, functionImport); Assert.Same(functionImport, mappingContext[storeFunction]); Assert.Same(storeFunction, mappingContext.MappedStoreFunctions().Single()); }
public void Removing_entity_set_mapping_removes_corresponding_entity_type() { var storeEntity = CreateEntityType("storeEntity"); var modelEntity = CreateEntityType("modelEntity"); var storeEntitySet = EntitySet.Create("storeEntitySet", null, null, null, storeEntity, null); var modelEntitySet = EntitySet.Create("modelEntitySet", null, null, null, modelEntity, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(storeEntity, modelEntity); mappingContext.AddMapping(storeEntitySet, modelEntitySet); Assert.Same(modelEntitySet, mappingContext.ConceptualEntitySets().Single()); Assert.Same(modelEntity, mappingContext.ConceptualEntityTypes().Single()); mappingContext.RemoveMapping(storeEntitySet); Assert.Empty(mappingContext.ConceptualEntitySets()); Assert.Empty(mappingContext.ConceptualEntityTypes()); }
public void BuildAssociationSetMappings_builds_conceptual_assocation_set_mapping_for_collapsed_store_entity_sets() { #region Setting up many to many relationship in the SSpace Teacher * -- 1 TeacherStudents 1 -- * Teachers var joinStoreEntityType = EntityType.Create( "TeacherStudents", "ns.Store", DataSpace.SSpace, new[] { "JoinTeacherId", "JoinStudentId" }, new[] { CreateStoreProperty("JoinTeacherId", "int"), CreateStoreProperty("JoinStudentId", "int") }, null); var joinStoreEntitySet = EntitySet.Create("TeacherStudentsSet", "dbo", "TeacherStudentTable", null, joinStoreEntityType, null); var storeTeacherEntityType = EntityType.Create( "Teacher", "ns.Store", DataSpace.SSpace, new[] { "TeacherId" }, new[] { CreateStoreProperty("TeacherId", "int") }, null); var storeTeacherEntitySet = EntitySet.Create("TeachersSet", "dbo", "Teachers", null, storeTeacherEntityType, null); var storeStudentEntityType = EntityType.Create( "Student", "ns.Store", DataSpace.SSpace, new[] { "StudentId" }, new[] { CreateStoreProperty("StudentId", "int") }, null); var storeStudentEntitySet = EntitySet.Create("StudentSet", "dbo", "Students", null, storeStudentEntityType, null); var storeTeachersEndMember = AssociationEndMember.Create( "Teachers", storeTeacherEntityType.GetReferenceType(), RelationshipMultiplicity.Many, OperationAction.None, null); var storeTeacherStudentsfromTeachersEndMember = AssociationEndMember.Create( "TeacherStudents_fromTeachers", joinStoreEntityType.GetReferenceType(), RelationshipMultiplicity.One, OperationAction.None, null); var storeTeacherAssociationType = AssociationType.Create( "Teacher_TeacherStudentsAssociationType", "ns.Store", false, DataSpace.SSpace, storeTeachersEndMember, storeTeacherStudentsfromTeachersEndMember, new ReferentialConstraint( storeTeachersEndMember, storeTeacherStudentsfromTeachersEndMember, storeTeacherEntityType.KeyProperties, joinStoreEntityType.KeyProperties.Where(p => p.Name == "JoinTeacherId")), null); var storeTeacherAssociationSet = AssociationSet.Create( "Teacher_TeacherStudents", storeTeacherAssociationType, storeTeacherEntitySet, joinStoreEntitySet, null); var storeStudentsEndMember = AssociationEndMember.Create( "Students", storeStudentEntityType.GetReferenceType(), RelationshipMultiplicity.Many, OperationAction.None, null); var storeTeacherStudentsfromStudentsEndMember = AssociationEndMember.Create( "TeacherStudents_fromStudents", joinStoreEntityType.GetReferenceType(), RelationshipMultiplicity.One, OperationAction.None, null); var storeStudentAssociationType = AssociationType.Create( "Student_TeacherStudentsAssociationType", "ns.Store", false, DataSpace.SSpace, storeStudentsEndMember, storeTeacherStudentsfromStudentsEndMember, new ReferentialConstraint( storeStudentsEndMember, storeTeacherStudentsfromStudentsEndMember, storeStudentEntityType.KeyProperties, joinStoreEntityType.KeyProperties.Where(p => p.Name == "JoinStudentId")), null); var storeStudentAssociationSet = AssociationSet.Create( "Student_TeacherStudents", storeStudentAssociationType, storeStudentEntitySet, joinStoreEntitySet, null); var collapsedAssociationSet = new CollapsibleEntityAssociationSets(joinStoreEntitySet); collapsedAssociationSet.AssociationSets.Add(storeTeacherAssociationSet); collapsedAssociationSet.AssociationSets.Add(storeStudentAssociationSet); #endregion #region Setting up many to many relationship in the CSpace Teacher * -- * Teachers var conceptualContainer = EntityContainer.Create("ConceptualContainer", DataSpace.CSpace, null, null, null); var edmIntTypeUsage = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)); var conceptualTeacherEntityType = EntityType.Create( "Teacher", "ns", DataSpace.CSpace, new[] { "TeacherId" }, new[] { EdmProperty.Create("TeacherId", edmIntTypeUsage) }, null); var conceptualTeacherEntitySet = EntitySet.Create("TeachersSet", null, null, null, conceptualTeacherEntityType, null); var conceptualStudentEntityType = EntityType.Create( "Student", "ns", DataSpace.CSpace, new[] { "StudentId" }, new[] { EdmProperty.Create("StudentId", edmIntTypeUsage) }, null); var conceptualStudentEntitySet = EntitySet.Create("StudentSet", "dbo", "Students", null, conceptualStudentEntityType, null); var conceptualTeachersEndMember = AssociationEndMember.Create( "TeachersEnd", conceptualTeacherEntityType.GetReferenceType(), RelationshipMultiplicity.Many, OperationAction.None, null); var conceptualStudentsEndMember = AssociationEndMember.Create( "StudentsEnd", conceptualStudentEntityType.GetReferenceType(), RelationshipMultiplicity.Many, OperationAction.None, null); var conceptualAssociationType = AssociationType.Create( "TeacherStudentAssociation", "ns.Model", false, DataSpace.CSpace, conceptualTeachersEndMember, conceptualStudentsEndMember, new ReferentialConstraint( conceptualTeachersEndMember, conceptualStudentsEndMember, conceptualTeacherEntityType.KeyProperties, conceptualStudentEntityType.KeyProperties), null); var conceptualAssociationSet = AssociationSet.Create( "TeacherStudentSet", conceptualAssociationType, conceptualTeacherEntitySet, conceptualStudentEntitySet, null); #endregion var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(collapsedAssociationSet, conceptualAssociationSet); mappingContext.AddMapping(storeTeachersEndMember, conceptualTeachersEndMember); mappingContext.AddMapping(storeStudentsEndMember, conceptualStudentsEndMember); mappingContext.AddMapping( storeTeacherAssociationSet.AssociationSetEnds.ElementAt(0), conceptualAssociationSet.AssociationSetEnds.ElementAt(0)); mappingContext.AddMapping( storeStudentAssociationSet.AssociationSetEnds.ElementAt(0), conceptualAssociationSet.AssociationSetEnds.ElementAt(1)); mappingContext.AddMapping( storeStudentEntityType.KeyProperties.Single(), conceptualStudentEntityType.KeyProperties.Single()); mappingContext.AddMapping( storeTeacherEntityType.KeyProperties.Single(), conceptualTeacherEntityType.KeyProperties.Single()); var storageEntitySetMapping = new EntityContainerMapping(conceptualContainer, null, null, false, false); var associationSetMapping = DbDatabaseMappingBuilder.BuildAssociationSetMappings(storageEntitySetMapping, mappingContext) .SingleOrDefault(); Assert.NotNull(associationSetMapping); var mappingFragment = associationSetMapping.TypeMappings.SingleOrDefault(); Assert.NotNull(mappingFragment); var propertyMappings = mappingFragment.MappingFragments.Single().PropertyMappings; Assert.Equal(2, propertyMappings.Count); Assert.Same(conceptualTeachersEndMember, ((EndPropertyMapping)propertyMappings[0]).AssociationEnd); Assert.Same(conceptualStudentsEndMember, ((EndPropertyMapping)propertyMappings[1]).AssociationEnd); var scalarPropertyMapping = ((EndPropertyMapping)propertyMappings[0]).PropertyMappings.Single(); Assert.Same(conceptualTeacherEntityType.KeyMembers.Single(), scalarPropertyMapping.Property); Assert.Same( joinStoreEntityType.KeyMembers.Single(m => m.Name == "JoinTeacherId"), scalarPropertyMapping.Column); scalarPropertyMapping = ((EndPropertyMapping)propertyMappings[1]).PropertyMappings.Single(); Assert.Same(conceptualStudentEntityType.KeyMembers.Single(), scalarPropertyMapping.Property); Assert.Same( joinStoreEntityType.KeyMembers.Single(m => m.Name == "JoinStudentId"), scalarPropertyMapping.Column); }
public void BuildComposableFunctionMapping_creates_valid_function_mapping() { var rowTypeProperty = CreateStoreProperty("p1", "int"); var complexTypeProperty = EdmProperty.Create( "p2", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32))); var functionImportReturnComplexType = ComplexType.Create( "c", "entityModel", DataSpace.CSpace, new[] { complexTypeProperty }, null); var storeFunction = EdmFunction.Create( "f_s", "storeModel", DataSpace.SSpace, new EdmFunctionPayload { IsComposable = true, IsFunctionImport = false, ReturnParameters = new[] { FunctionParameter.Create( "ReturnType", RowType.Create(new[] { rowTypeProperty }, null).GetCollectionType(), ParameterMode.ReturnValue) } }, null); var functionImport = EdmFunction.Create( "f_c", "entityModel", DataSpace.CSpace, new EdmFunctionPayload { IsComposable = true, IsFunctionImport = false, ReturnParameters = new[] { FunctionParameter.Create( "ReturnType", functionImportReturnComplexType.GetCollectionType(), ParameterMode.ReturnValue) } }, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(rowTypeProperty, complexTypeProperty); mappingContext.AddMapping(storeFunction, functionImport); var functionImportMapping = DbDatabaseMappingBuilder.BuildComposableFunctionMapping(storeFunction, mappingContext); Assert.NotNull(functionImportMapping); Assert.Same(storeFunction, functionImportMapping.TargetFunction); Assert.Same(functionImport, functionImportMapping.FunctionImport); var structuralTypeMappings = functionImportMapping.StructuralTypeMappings; Assert.NotNull(structuralTypeMappings); Assert.Same(functionImportReturnComplexType, structuralTypeMappings.Single().Item1); Assert.Empty(structuralTypeMappings.Single().Item2); Assert.Same(complexTypeProperty, structuralTypeMappings.Single().Item3.Single().Property); Assert.Same(rowTypeProperty, ((ScalarPropertyMapping)structuralTypeMappings.Single().Item3.Single()).Column); }
public void Can_add_and_get_association_end_member_mapping() { var et1 = CreateEntityType("et1"); var et2 = CreateEntityType("et2"); var aem1 = AssociationEndMember.Create("aem1", et1.GetReferenceType(), RelationshipMultiplicity.One, OperationAction.None, null); var aem2 = AssociationEndMember.Create("aem2", et2.GetReferenceType(), RelationshipMultiplicity.One, OperationAction.None, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(aem1, aem2); Assert.Same(aem2, mappingContext[aem1]); }
public void BuildEntitySetMapping_creates_valid_entity_set_mapping() { var storeEntityType = EntityType.Create("foo_S", "bar_S", DataSpace.SSpace, null, null, null); var modelEntityType = EntityType.Create("foo_C", "bar_C", DataSpace.CSpace, null, null, null); var storeEntitySet = EntitySet.Create("ES_S", "Ns_S", null, null, storeEntityType, null); var storeContainer = EntityContainer.Create("C_S", DataSpace.SSpace, new[] { storeEntitySet }, null, null); var modelEntitySet = EntitySet.Create("ES_C", "Ns_C", null, null, storeEntityType, null); var modelContainer = EntityContainer.Create("C_C", DataSpace.SSpace, new[] { modelEntitySet }, null, null); var storageContainerMapping = new EntityContainerMapping(modelContainer, storeContainer, null, false, false); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(storeEntitySet, modelEntitySet); mappingContext.AddMapping(storeEntityType, modelEntityType); var entitySetMapping = DbDatabaseMappingBuilder.BuildEntitySetMappings(storageContainerMapping, mappingContext).Single(); Assert.Same(modelEntitySet, entitySetMapping.EntitySet); Assert.Equal(1, entitySetMapping.EntityTypeMappings.Count()); }
public void Build_builds_valid_DbDatabaseMapping_for_functions() { var rowTypeProperty = CreateStoreProperty("p1", "int"); var complexTypeProperty = EdmProperty.Create( "p2", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32))); var functionImportReturnComplexType = ComplexType.Create( "CT", "entityModel", DataSpace.CSpace, new[] { complexTypeProperty }, null); var storeFunction = EdmFunction.Create( "f_s", "storeModel", DataSpace.SSpace, new EdmFunctionPayload { IsComposable = true, IsFunctionImport = false, ReturnParameters = new[] { FunctionParameter.Create( "ReturnType", RowType.Create(new[] { rowTypeProperty }, null).GetCollectionType(), ParameterMode.ReturnValue) } }, null); var functionImport = EdmFunction.Create( "f_c", "entityModel", DataSpace.CSpace, new EdmFunctionPayload { IsComposable = true, IsFunctionImport = true, ReturnParameters = new[] { FunctionParameter.Create( "ReturnType", functionImportReturnComplexType.GetCollectionType(), ParameterMode.ReturnValue) } }, null); var modelContainer = EntityContainer.Create("C_C", DataSpace.CSpace, new EntitySet[0], new[] { functionImport }, null); var storeContainer = EntityContainer.Create("C_S", DataSpace.SSpace, new EntitySet[0], null, null); var storeModel = EdmModel.CreateStoreModel(storeContainer, null, null); storeModel.AddItem(storeFunction); var mappingContext = new SimpleMappingContext(storeModel, true); mappingContext.AddMapping(rowTypeProperty, complexTypeProperty); mappingContext.AddMapping(storeFunction, functionImport); mappingContext.AddMapping(storeContainer, modelContainer); var entityModel = DbDatabaseMappingBuilder.Build(mappingContext).ConceptualModel; Assert.NotNull(entityModel); Assert.Equal(new[] { "f_c" }, entityModel.Containers.Single().FunctionImports.Select(f => f.Name)); Assert.Equal(new[] { "CT" }, entityModel.ComplexTypes.Select(t => t.Name)); }
// internal for testing internal EntityType GenerateEntityType( SimpleMappingContext mappingContext, EntityType storeEntityType, UniqueIdentifierService globallyUniqueTypeNames) { Debug.Assert(mappingContext != null, "mappingContext != null"); Debug.Assert(storeEntityType != null, "storeEntityType != null"); Debug.Assert(globallyUniqueTypeNames != null, "globallyUniqueTypeNames != null"); var conceptualEntityTypeName = CreateModelName( (_pluralizationService != null) ? _pluralizationService.Singularize(storeEntityType.Name) : storeEntityType.Name, globallyUniqueTypeNames); var uniquePropertyNameService = new UniqueIdentifierService(); uniquePropertyNameService.AdjustIdentifier(conceptualEntityTypeName); var edmMembers = new List<EdmMember>(); var keyMemberNames = new List<string>(); foreach (var storeProperty in storeEntityType.Properties) { // cannot skip this even if the store property is foreign key and generating foreign keys is disabled // since it creates property mappings the will be used when mapping association types. var conceptualProperty = GenerateScalarProperty(mappingContext, storeProperty, uniquePropertyNameService); if (_generateForeignKeyProperties || !mappingContext.StoreForeignKeyProperties.Contains(storeProperty) || storeEntityType.KeyMembers.Contains(storeProperty)) { edmMembers.Add(conceptualProperty); if (storeEntityType.KeyMembers.Contains(storeProperty)) { keyMemberNames.Add(conceptualProperty.Name); } } } var conceptualEntity = EntityType.Create( conceptualEntityTypeName, _namespaceName, DataSpace.CSpace, keyMemberNames, edmMembers, null); mappingContext.AddMapping(storeEntityType, conceptualEntity); return conceptualEntity; }
public void BuildComposableFunctionMapping_creates_valid_function_mapping() { var rowTypeProperty = CreateStoreProperty("p1", "int"); var complexTypeProperty = EdmProperty.Create( "p2", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32))); var functionImportReturnComplexType = ComplexType.Create( "c", "entityModel", DataSpace.CSpace, new[] { complexTypeProperty }, null); var storeFunction = EdmFunction.Create( "f_s", "storeModel", DataSpace.SSpace, new EdmFunctionPayload { IsComposable = true, IsFunctionImport = false, ReturnParameters = new[] { FunctionParameter.Create( "ReturnType", RowType.Create(new[] { rowTypeProperty }, null).GetCollectionType(), ParameterMode.ReturnValue) } }, null); var functionImport = EdmFunction.Create( "f_c", "entityModel", DataSpace.CSpace, new EdmFunctionPayload { IsComposable = true, IsFunctionImport = false, ReturnParameters = new[] { FunctionParameter.Create( "ReturnType", functionImportReturnComplexType.GetCollectionType(), ParameterMode.ReturnValue) } }, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(rowTypeProperty, complexTypeProperty); mappingContext.AddMapping(storeFunction, functionImport); var functionImportMapping = DbDatabaseMappingBuilder.BuildComposableFunctionMapping(storeFunction, mappingContext); Assert.NotNull(functionImportMapping); Assert.Same(storeFunction, functionImportMapping.TargetFunction); Assert.Same(functionImport, functionImportMapping.FunctionImport); var structuralTypeMappings = functionImportMapping.StructuralTypeMappings; Assert.NotNull(structuralTypeMappings); Assert.Same(functionImportReturnComplexType, structuralTypeMappings.Single().Item1); Assert.Empty(structuralTypeMappings.Single().Item2); Assert.Same(complexTypeProperty, structuralTypeMappings.Single().Item3.Single().Property); Assert.Same(rowTypeProperty, ((ScalarPropertyMapping)structuralTypeMappings.Single().Item3.Single()).Column); }
public void Can_add_and_get_association_set_end_mapping() { var et1 = CreateEntityType("et1"); var et2 = CreateEntityType("et2"); var es1 = EntitySet.Create("es1", null, null, null, et1, null); var es2 = EntitySet.Create("es2", null, null, null, et2, null); var aem1 = AssociationEndMember.Create("aem1", et1.GetReferenceType(), RelationshipMultiplicity.One, OperationAction.None, null); var aem2 = AssociationEndMember.Create("aem2", et2.GetReferenceType(), RelationshipMultiplicity.One, OperationAction.None, null); var at1 = AssociationType.Create("at1", "ns", false, DataSpace.CSpace, aem1, aem2, null, null); var as1 = AssociationSet.Create("as1", at1, es1, es2, null); Assert.Equal(2, as1.AssociationSetEnds.Count); var ase1 = as1.AssociationSetEnds[0]; var ase2 = as1.AssociationSetEnds[1]; var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(ase1, ase2); Assert.Same(ase2, mappingContext[ase1]); }
public void ConceptualAssociationSets_returns_associationsets_for_collapsed_entity_sets() { var storeEntity = CreateEntityType("storeEntity"); var storeEntitySet = EntitySet.Create("storeEntitySet", null, null, null, storeEntity, null); var collapsibleAssociationSet = new CollapsibleEntityAssociationSets(storeEntitySet); var associationType = AssociationType.Create("modelAssociationType", "ns", false, DataSpace.CSpace, null, null, null, null); var associationSet = AssociationSet.Create("modelAssociationType", associationType, null, null, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); Assert.Empty(mappingContext.ConceptualAssociationSets()); mappingContext.AddMapping(collapsibleAssociationSet, associationSet); Assert.Equal(1, mappingContext.ConceptualAssociationSets().Count()); Assert.Same(associationSet, mappingContext.ConceptualAssociationSets().Single()); }
public void Build_builds_valid_DbDatabaseMapping_for_functions() { var rowTypeProperty = CreateStoreProperty("p1", "int"); var complexTypeProperty = EdmProperty.Create( "p2", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32))); var functionImportReturnComplexType = ComplexType.Create( "CT", "entityModel", DataSpace.CSpace, new[] { complexTypeProperty }, null); var storeFunction = EdmFunction.Create( "f_s", "storeModel", DataSpace.SSpace, new EdmFunctionPayload { IsComposable = true, IsFunctionImport = false, ReturnParameters = new[] { FunctionParameter.Create( "ReturnType", RowType.Create(new[] { rowTypeProperty }, null).GetCollectionType(), ParameterMode.ReturnValue) } }, null); var functionImport = EdmFunction.Create( "f_c", "entityModel", DataSpace.CSpace, new EdmFunctionPayload { IsComposable = true, IsFunctionImport = true, ReturnParameters = new[] { FunctionParameter.Create( "ReturnType", functionImportReturnComplexType.GetCollectionType(), ParameterMode.ReturnValue) } }, null); var modelContainer = EntityContainer.Create("C_C", DataSpace.CSpace, new EntitySet[0], new[] { functionImport }, null); var storeContainer = EntityContainer.Create("C_S", DataSpace.SSpace, new EntitySet[0], null, null); var storeModel = EdmModel.CreateStoreModel(storeContainer, null, null); storeModel.AddItem(storeFunction); var mappingContext = new SimpleMappingContext(storeModel, true); mappingContext.AddMapping(rowTypeProperty, complexTypeProperty); mappingContext.AddMapping(storeFunction, functionImport); mappingContext.AddMapping(storeContainer, modelContainer); var entityModel = DbDatabaseMappingBuilder.Build(mappingContext).ConceptualModel; Assert.NotNull(entityModel); Assert.Equal(new[] { "f_c" }, entityModel.Containers.Single().FunctionImports.Select(f => f.Name)); Assert.Equal(new[] { "CT" }, entityModel.ComplexTypes.Select(t => t.Name)); }
public void Can_add_get_association_type_mapping() { var storeAssociationType = AssociationType.Create("storeAssociationType", "ns.Store", false, DataSpace.SSpace, null, null, null, null); var conceptualAssociationType = AssociationType.Create("conceptualAssociationType", "ns", false, DataSpace.CSpace, null, null, null, null); var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true); mappingContext.AddMapping(storeAssociationType, conceptualAssociationType); Assert.Same(conceptualAssociationType, mappingContext[storeAssociationType]); AssociationType outAssociationType; Assert.True(mappingContext.TryGetValue(storeAssociationType, out outAssociationType)); Assert.Same(conceptualAssociationType, outAssociationType); Assert.False(mappingContext.TryGetValue(conceptualAssociationType, out outAssociationType)); Assert.Null(outAssociationType); }