Пример #1
0
        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());
        }
Пример #3
0
        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);
        }
Пример #5
0
        // 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);
        }
Пример #6
0
        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());
        }
Пример #12
0
        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]);
        }
Пример #16
0
        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());
        }
Пример #22
0
        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);
        }
Пример #25
0
        // 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]);
        }
Пример #27
0
        // 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);
                    }
                }
            }
        }
Пример #28
0
        // 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);
        }
Пример #29
0
        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);
        }
Пример #32
0
        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));
        }
Пример #33
0
        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));
        }
Пример #34
0
        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;
        }
Пример #36
0
        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);
        }
Пример #51
0
        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());
        }
Пример #59
0
        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);
        }