public void WriteMappingFragment_should_write_store_entity_set_name()
        {
            var fixture = new Fixture();

            var entityType      = new EntityType("E", "N", DataSpace.CSpace);
            var entitySet       = new EntitySet("ES", "S", null, null, entityType);
            var entityContainer = new EntityContainer("EC", DataSpace.SSpace);

            entityContainer.AddEntitySetBase(entitySet);

            var storageEntitySetMapping
                = new StorageEntitySetMapping(
                      entitySet,
                      new StorageEntityContainerMapping(entityContainer));

            StorageTypeMapping typeMapping = new StorageEntityTypeMapping(storageEntitySetMapping);

            var mappingFragment = new StorageMappingFragment(entitySet, typeMapping, false);

            fixture.Writer.WriteMappingFragmentElement(mappingFragment);

            Assert.Equal(
                @"<MappingFragment StoreEntitySet=""ES"" />",
                fixture.ToString());
        }
        public static void RemoveDefaultDiscriminator(
            this StorageMappingFragment entityTypeMappingFragment, StorageEntitySetMapping entitySetMapping)
        {
            DebugCheck.NotNull(entityTypeMappingFragment);

            var discriminatorColumn = entityTypeMappingFragment.RemoveDefaultDiscriminatorCondition();

            if (discriminatorColumn != null)
            {
                var table = entityTypeMappingFragment.Table;

                table.Properties
                .Where(c => c.Name.Equals(discriminatorColumn.Name, StringComparison.Ordinal))
                .ToList()
                .Each(table.RemoveMember);
            }

            if (entitySetMapping != null &&
                entityTypeMappingFragment.IsConditionOnlyFragment()
                &&
                !entityTypeMappingFragment.ColumnConditions.Any())
            {
                var entityTypeMapping =
                    entitySetMapping.EntityTypeMappings.Single(
                        etm => etm.MappingFragments.Contains(entityTypeMappingFragment));

                entityTypeMapping.RemoveFragment(entityTypeMappingFragment);

                if (entityTypeMapping.MappingFragments.Count == 0)
                {
                    entitySetMapping.RemoveTypeMapping(entityTypeMapping);
                }
            }
        }
Esempio n. 3
0
        public void WriteEntitySetMappingElement(StorageEntitySetMapping entitySetMapping)
        {
            DebugCheck.NotNull(entitySetMapping);

            _xmlWriter.WriteStartElement(StorageMslConstructs.EntitySetMappingElement);
            _xmlWriter.WriteAttributeString(StorageMslConstructs.EntitySetMappingNameAttribute, entitySetMapping.EntitySet.Name);

            foreach (var entityTypeMapping in entitySetMapping.EntityTypeMappings)
            {
                WriteEntityTypeMappingElement(entityTypeMapping);
            }

            foreach (var modificationFunctionMapping in entitySetMapping.ModificationFunctionMappings)
            {
                _xmlWriter.WriteStartElement(StorageMslConstructs.EntityTypeMappingElement);
                _xmlWriter.WriteAttributeString(
                    StorageMslConstructs.EntityTypeMappingTypeNameAttribute,
                    GetEntityTypeName(_entityTypeNamespace + "." + modificationFunctionMapping.EntityType.Name, false));

                WriteModificationFunctionMapping(modificationFunctionMapping);

                _xmlWriter.WriteEndElement();
            }

            _xmlWriter.WriteEndElement();
        }
 internal EntitySetTranslator(StorageEntitySetMapping setMapping)
 {
     Debug.Assert(null != setMapping && null != setMapping.ModificationFunctionMappings &&
         0 < setMapping.ModificationFunctionMappings.Count, "set mapping must exist and must specify function mappings");
     m_typeMappings = new Dictionary<EntityType, StorageEntityTypeModificationFunctionMapping>();
     foreach (StorageEntityTypeModificationFunctionMapping typeMapping in setMapping.ModificationFunctionMappings)
     {
         m_typeMappings.Add(typeMapping.EntityType, typeMapping);
     }
 }
 internal EntitySetTranslator(StorageEntitySetMapping setMapping)
 {
     Debug.Assert(null != setMapping && null != setMapping.ModificationFunctionMappings &&
                  0 < setMapping.ModificationFunctionMappings.Count, "set mapping must exist and must specify function mappings");
     m_typeMappings = new Dictionary <EntityType, StorageEntityTypeModificationFunctionMapping>();
     foreach (StorageEntityTypeModificationFunctionMapping typeMapping in setMapping.ModificationFunctionMappings)
     {
         m_typeMappings.Add(typeMapping.EntityType, typeMapping);
     }
 }
        private void WriteEntitySetMappingElement(StorageEntitySetMapping set)
        {
            _xmlWriter.WriteStartElement(StorageMslConstructs.EntitySetMappingElement);
            _xmlWriter.WriteAttributeString(StorageMslConstructs.EntitySetMappingNameAttribute, set.EntitySet.Name);

            foreach (var entityTypeMapping in set.EntityTypeMappings)
            {
                WriteEntityTypeMappingElement(entityTypeMapping);
            }
            _xmlWriter.WriteEndElement();
        }
        public static StorageEntitySetMapping AddEntitySetMapping(
            this DbDatabaseMapping databaseMapping, EntitySet entitySet)
        {
            DebugCheck.NotNull(databaseMapping);
            DebugCheck.NotNull(entitySet);

            var entitySetMapping = new StorageEntitySetMapping(entitySet, null);

            databaseMapping
            .EntityContainerMappings
            .Single()
            .AddEntitySetMapping(entitySetMapping);

            return(entitySetMapping);
        }
        private static IEnumerable <ColumnMappingBuilder> GetColumnMappings(
            EntityType entityType, StorageEntitySetMapping entitySetMapping)
        {
            DebugCheck.NotNull(entityType);
            DebugCheck.NotNull(entitySetMapping);

            return(new[] { entityType }
                   .Concat(GetParents(entityType))
                   .SelectMany(
                       et => entitySetMapping
                       .TypeMappings
                       .Where(stm => stm.Types.Contains(et))
                       .SelectMany(stm => stm.MappingFragments)
                       .SelectMany(mf => mf.ColumnMappings)));
        }
        public void WriteEntitySetMappingElement_should_write_modification_function_mappings()
        {
            var fixture = new Fixture();

            var entityType      = new EntityType("E", "N", DataSpace.CSpace);
            var entitySet       = new EntitySet("ES", "S", null, null, entityType);
            var entityContainer = new EntityContainer("EC", DataSpace.SSpace);

            entityContainer.AddEntitySetBase(entitySet);

            var storageEntitySetMapping
                = new StorageEntitySetMapping(
                      entitySet,
                      new StorageEntityContainerMapping(entityContainer));

            var storageModificationFunctionMapping
                = new StorageModificationFunctionMapping(
                      entitySet,
                      entityType,
                      new EdmFunction("F", "N", DataSpace.SSpace, new EdmFunctionPayload()),
                      Enumerable.Empty <StorageModificationFunctionParameterBinding>(),
                      null,
                      null);

            storageEntitySetMapping.AddModificationFunctionMapping(
                new StorageEntityTypeModificationFunctionMapping(
                    entityType,
                    storageModificationFunctionMapping,
                    storageModificationFunctionMapping,
                    storageModificationFunctionMapping));

            fixture.Writer.WriteEntitySetMappingElement(storageEntitySetMapping);

            Assert.Equal(
                @"<EntitySetMapping Name=""ES"">
  <EntityTypeMapping TypeName="".E"">
    <ModificationFunctionMapping>
      <InsertFunction FunctionName=""N.F"" />
      <UpdateFunction FunctionName=""N.F"" />
      <DeleteFunction FunctionName=""N.F"" />
    </ModificationFunctionMapping>
  </EntityTypeMapping>
</EntitySetMapping>",
                fixture.ToString());
        }
Esempio n. 10
0
        private static bool HasBaseWithIsTypeOf(StorageEntitySetMapping entitySetMapping, EntityType entityType)
        {
            var baseType = entityType.BaseType;

            while (baseType != null)
            {
                if (entitySetMapping.EntityTypeMappings
                    .Where(etm => etm.EntityType == baseType)
                    .Any(etm => etm.IsHierarchyMapping))
                {
                    return(true);
                }

                baseType = baseType.BaseType;
            }

            return(false);
        }
Esempio n. 11
0
        internal static IEnumerable <StorageEntityTypeModificationFunctionMapping> GetModificationFunctionMappingsForEntitySetAndType(StorageMappingItemCollection mappingCollection, EntityContainer container, EntitySetBase entitySet, EntityTypeBase entityType)
        {
            StorageEntityContainerMapping containerMapping = GetEntityContainerMap(mappingCollection, container);

            StorageSetMapping       extentMap        = containerMapping.GetSetMapping(entitySet.Name);
            StorageEntitySetMapping entitySetMapping = extentMap as StorageEntitySetMapping;

            //The Set may have no mapping
            if (entitySetMapping != null)
            {
                if (entitySetMapping != null) //could be association set mapping
                {
                    foreach (var v in entitySetMapping.ModificationFunctionMappings.Where(functionMap => functionMap.EntityType.Equals(entityType)))
                    {
                        yield return(v);
                    }
                }
            }
        }
Esempio n. 12
0
 /// <summary>
 /// Yields all members appearing in function mapping result bindings.
 /// </summary>
 /// <param name="entitySetMapping">Set mapping to examine</param>
 /// <returns>All result bindings</returns>
 private IEnumerable <EdmMember> GetMembersWithResultBinding(StorageEntitySetMapping entitySetMapping)
 {
     foreach (StorageEntityTypeModificationFunctionMapping typeFunctionMapping in entitySetMapping.ModificationFunctionMappings)
     {
         // look at all result bindings for insert and update commands
         if (null != typeFunctionMapping.InsertFunctionMapping && null != typeFunctionMapping.InsertFunctionMapping.ResultBindings)
         {
             foreach (StorageModificationFunctionResultBinding binding in typeFunctionMapping.InsertFunctionMapping.ResultBindings)
             {
                 yield return(binding.Property);
             }
         }
         if (null != typeFunctionMapping.UpdateFunctionMapping && null != typeFunctionMapping.UpdateFunctionMapping.ResultBindings)
         {
             foreach (StorageModificationFunctionResultBinding binding in typeFunctionMapping.UpdateFunctionMapping.ResultBindings)
             {
                 yield return(binding.Property);
             }
         }
     }
 }
Esempio n. 13
0
        public void Generate(
            EntityType entityType,
            IEnumerable <EdmProperty> properties,
            StorageEntitySetMapping entitySetMapping,
            StorageMappingFragment entityTypeMappingFragment,
            IList <EdmProperty> propertyPath,
            bool createNewColumn)
        {
            DebugCheck.NotNull(entityType);
            DebugCheck.NotNull(properties);
            DebugCheck.NotNull(entityTypeMappingFragment);
            DebugCheck.NotNull(propertyPath);

            var rootDeclaredProperties = entityType.GetRootType().DeclaredProperties;

            foreach (var property in properties)
            {
                if (property.IsComplexType &&
                    propertyPath.Any(
                        p => p.IsComplexType &&
                        (p.ComplexType == property.ComplexType)))
                {
                    throw Error.CircularComplexTypeHierarchy();
                }

                propertyPath.Add(property);

                if (property.IsComplexType)
                {
                    Generate(
                        entityType,
                        property.ComplexType.Properties,
                        entitySetMapping,
                        entityTypeMappingFragment,
                        propertyPath,
                        createNewColumn);
                }
                else
                {
                    var tableColumn
                        = entitySetMapping.EntityTypeMappings
                          .SelectMany(etm => etm.MappingFragments)
                          .SelectMany(etmf => etmf.ColumnMappings)
                          .Where(pm => pm.PropertyPath.SequenceEqual(propertyPath))
                          .Select(pm => pm.ColumnProperty)
                          .FirstOrDefault();

                    if (tableColumn == null || createNewColumn)
                    {
                        var columnName
                            = string.Join("_", propertyPath.Select(p => p.Name));

                        tableColumn
                            = MapTableColumn(
                                  property,
                                  columnName,
                                  !rootDeclaredProperties.Contains(propertyPath.First()));

                        entityTypeMappingFragment.Table.AddColumn(tableColumn);

                        if (entityType.KeyProperties().Contains(property))
                        {
                            entityTypeMappingFragment.Table.AddKeyMember(tableColumn);
                        }
                    }

                    entityTypeMappingFragment.AddColumnMapping(
                        new ColumnMappingBuilder(tableColumn, propertyPath.ToList()));
                }

                propertyPath.Remove(property);
            }
        }
 /// <summary>
 /// Initialize a translator for the given entity set mapping.
 /// </summary>
 /// <param name="setMapping">Entity set mapping.</param>
 /// <returns>Translator.</returns>
 internal static ModificationFunctionMappingTranslator CreateEntitySetTranslator(
     StorageEntitySetMapping setMapping)
 {
     return new EntitySetTranslator(setMapping);
 }
 /// <summary>
 ///     Initialize a translator for the given entity set mapping.
 /// </summary>
 /// <param name="setMapping"> Entity set mapping. </param>
 /// <returns> Translator. </returns>
 internal static ModificationFunctionMappingTranslator CreateEntitySetTranslator(
     StorageEntitySetMapping setMapping)
 {
     return(new EntitySetTranslator(setMapping));
 }