private SimpleCollectionColumnMap BuildSimpleEntitySetColumnMap(Mock <MetadataWorkspace> metadataWorkspaceMock, CodeFirstOSpaceTypeFactory codeFirstOSpaceTypeFactory = null) { var cSpaceEntityType = new EntityType(typeof(SimpleEntity).Name, "N", DataSpace.CSpace); var intTypeUsage = TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), new FacetValues { Nullable = false }); cSpaceEntityType.AddMember(new EdmProperty("Id", intTypeUsage)); cSpaceEntityType.AddMember(new EdmProperty("Count", intTypeUsage)); var entityTypeUsage = TypeUsage.Create(cSpaceEntityType); var idScalarMap = new ScalarColumnMap(intTypeUsage, "Id", 0, 0); var entityMap = new EntityColumnMap( entityTypeUsage, "E", new[] { idScalarMap, new ScalarColumnMap(intTypeUsage, "Count", 0, 1) }, new SimpleEntityIdentity(null, new SimpleColumnMap[] { idScalarMap })); var collectionMap = new SimpleCollectionColumnMap( entityTypeUsage, "MockCollectionType", entityMap, null, null); codeFirstOSpaceTypeFactory = codeFirstOSpaceTypeFactory ?? new CodeFirstOSpaceTypeFactory(); var oSpaceEntityType = codeFirstOSpaceTypeFactory.TryCreateType(typeof(SimpleEntity), cSpaceEntityType); codeFirstOSpaceTypeFactory.CspaceToOspace.Add(cSpaceEntityType, oSpaceEntityType); metadataWorkspaceMock.Setup(m => m.GetItem <EdmType>("N.SimpleEntity", DataSpace.OSpace)) .Returns(oSpaceEntityType); return(collectionMap); }
public void TranslateColumnMap_returns_correct_columntypes_and_nullablecolumns_for_discriminated_types() { var metadataWorkspaceMock = new Mock <MetadataWorkspace>(); metadataWorkspaceMock.Setup(m => m.GetQueryCacheManager()).Returns(QueryCacheManager.Create()); var typeChoices = new Dictionary <object, TypedColumnMap>(); var entityColumnMap = (EntityColumnMap)BuildSimpleEntitySetColumnMap(metadataWorkspaceMock).Element; typeChoices.Add(true, entityColumnMap); var recordMap = new SimplePolymorphicColumnMap( entityColumnMap.Type, "E", new ColumnMap[0], new ScalarColumnMap(TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Boolean)), "discriminator", 0, 2), typeChoices); var collectionMap = new SimpleCollectionColumnMap( entityColumnMap.Type, "MockCollectionType", recordMap, null, null); var factory = new Translator().TranslateColumnMap <object>( collectionMap, metadataWorkspaceMock.Object, new SpanIndex(), MergeOption.NoTracking, streaming: false, valueLayer: false); Assert.NotNull(factory); Assert.Equal(new[] { typeof(int), typeof(int), typeof(bool) }, factory.ColumnTypes); Assert.Equal(new[] { true, true, true }, factory.NullableColumns); }
public void TranslateColumnMap_returns_correct_columntypes_and_nullablecolumns_for_anonymous_types() { var metadataWorkspaceMock = new Mock <MetadataWorkspace>(); metadataWorkspaceMock.Setup(m => m.GetQueryCacheManager()).Returns(QueryCacheManager.Create()); var edmProperties = new [] { new EdmProperty("P1Int", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), new FacetValues { Nullable = false })), new EdmProperty("P2Bool", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Boolean))) }; var cSpaceEntityType = new RowType(edmProperties); var entityTypeUsage = TypeUsage.Create(cSpaceEntityType); var recordMap = new RecordColumnMap( entityTypeUsage, "E", new[] { new ScalarColumnMap(cSpaceEntityType.Properties[0].TypeUsage, cSpaceEntityType.Properties[0].Name, 0, 0) }, new ScalarColumnMap(cSpaceEntityType.Properties[1].TypeUsage, cSpaceEntityType.Properties[1].Name, 0, 1)); var collectionMap = new SimpleCollectionColumnMap( entityTypeUsage, "MockCollectionType", recordMap, null, null); var factory = new Translator().TranslateColumnMap <object>( collectionMap, metadataWorkspaceMock.Object, new SpanIndex(), MergeOption.NoTracking, streaming: false, valueLayer: false); Assert.NotNull(factory); Assert.Equal(new[] { typeof(int), null }, factory.ColumnTypes); Assert.Equal(new[] { true, true }, factory.NullableColumns); }
private TypeUsage DetermineStoreResultType( FunctionImportMappingNonComposable mapping, int resultSetIndex, out EntityCommandDefinition.IColumnMapGenerator columnMapGenerator) { EdmFunction functionImport = mapping.FunctionImport; StructuralType returnType; TypeUsage type; if (MetadataHelper.TryGetFunctionImportReturnType <StructuralType>(functionImport, resultSetIndex, out returnType)) { EntityCommandDefinition.ValidateEdmResultType((EdmType)returnType, functionImport); EntitySet entitySet = functionImport.EntitySets.Count > resultSetIndex ? functionImport.EntitySets[resultSetIndex] : (EntitySet)null; columnMapGenerator = (EntityCommandDefinition.IColumnMapGenerator) new EntityCommandDefinition.FunctionColumnMapGenerator(mapping, resultSetIndex, entitySet, returnType, this._columnMapFactory); type = mapping.GetExpectedTargetResultType(resultSetIndex); } else { FunctionParameter returnParameter = MetadataHelper.GetReturnParameter(functionImport, resultSetIndex); if (returnParameter != null && returnParameter.TypeUsage != null) { type = returnParameter.TypeUsage; ScalarColumnMap scalarColumnMap = new ScalarColumnMap(((CollectionType)type.EdmType).TypeUsage, string.Empty, 0, 0); SimpleCollectionColumnMap collectionColumnMap = new SimpleCollectionColumnMap(type, string.Empty, (ColumnMap)scalarColumnMap, (SimpleColumnMap[])null, (SimpleColumnMap[])null); columnMapGenerator = (EntityCommandDefinition.IColumnMapGenerator) new EntityCommandDefinition.ConstantColumnMapGenerator((ColumnMap)collectionColumnMap, 1); } else { type = (TypeUsage)null; columnMapGenerator = (EntityCommandDefinition.IColumnMapGenerator) new EntityCommandDefinition.ConstantColumnMapGenerator((ColumnMap)null, 0); } } return(type); }
/// <summary> /// Determines the store type for a function import. /// </summary> private TypeUsage DetermineStoreResultType(MetadataWorkspace workspace, FunctionImportMappingNonComposable mapping, int resultSetIndex, out IColumnMapGenerator columnMapGenerator) { // Determine column maps and infer result types for the mapped function. There are four varieties: // Collection(Entity) // Collection(PrimitiveType) // Collection(ComplexType) // No result type TypeUsage storeResultType; { StructuralType baseStructuralType; EdmFunction functionImport = mapping.FunctionImport; // Collection(Entity) or Collection(ComplexType) if (MetadataHelper.TryGetFunctionImportReturnType <StructuralType>(functionImport, resultSetIndex, out baseStructuralType)) { ValidateEdmResultType(baseStructuralType, functionImport); //Note: Defensive check for historic reasons, we expect functionImport.EntitySets.Count > resultSetIndex EntitySet entitySet = functionImport.EntitySets.Count > resultSetIndex ? functionImport.EntitySets[resultSetIndex] : null; columnMapGenerator = new FunctionColumnMapGenerator(mapping, resultSetIndex, entitySet, baseStructuralType); // We don't actually know the return type for the stored procedure, but we can infer // one based on the mapping (i.e.: a column for every property of the mapped types // and for all discriminator columns) storeResultType = mapping.GetExpectedTargetResultType(workspace, resultSetIndex); } // Collection(PrimitiveType) else { FunctionParameter returnParameter = MetadataHelper.GetReturnParameter(functionImport, resultSetIndex); if (returnParameter != null && returnParameter.TypeUsage != null) { // Get metadata description of the return type storeResultType = returnParameter.TypeUsage; Debug.Assert(storeResultType.EdmType.BuiltInTypeKind == BuiltInTypeKind.CollectionType, "FunctionImport currently supports only collection result type"); TypeUsage elementType = ((CollectionType)storeResultType.EdmType).TypeUsage; Debug.Assert(Helper.IsScalarType(elementType.EdmType) , "FunctionImport supports only Collection(Entity), Collection(Enum) and Collection(Primitive)"); // Build collection column map where the first column of the store result is assumed // to contain the primitive type values. ScalarColumnMap scalarColumnMap = new ScalarColumnMap(elementType, string.Empty, 0, 0); SimpleCollectionColumnMap collectionColumnMap = new SimpleCollectionColumnMap(storeResultType, string.Empty, scalarColumnMap, null, null); columnMapGenerator = new ConstantColumnMapGenerator(collectionColumnMap, 1); } // No result type else { storeResultType = null; columnMapGenerator = new ConstantColumnMapGenerator(null, 0); } } } return(storeResultType); }
public void TranslateColumnMap_returns_correct_columntypes_and_nullablecolumns_for_complex_types() { var metadataWorkspaceMock = new Mock <MetadataWorkspace>(); metadataWorkspaceMock.Setup(m => m.GetQueryCacheManager()).Returns(QueryCacheManager.Create()); var cSpaceComplexType = new ComplexType("C"); var intTypeUsage = TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), new FacetValues { Nullable = false }); cSpaceComplexType.AddMember(new EdmProperty("Id", intTypeUsage)); cSpaceComplexType.AddMember(new EdmProperty("Count", intTypeUsage)); var complexTypeUsage = TypeUsage.Create(cSpaceComplexType); var recordMap = new ComplexTypeColumnMap( complexTypeUsage, "E", new[] { new ScalarColumnMap(cSpaceComplexType.Properties[0].TypeUsage, cSpaceComplexType.Properties[0].Name, 0, 0) }, new ScalarColumnMap(cSpaceComplexType.Properties[1].TypeUsage, cSpaceComplexType.Properties[1].Name, 0, 1)); var collectionMap = new SimpleCollectionColumnMap( complexTypeUsage, "MockCollectionType", recordMap, null, null); metadataWorkspaceMock.Setup(m => m.GetItem <EdmType>(It.IsAny <string>(), DataSpace.OSpace)) .Returns(new CodeFirstOSpaceTypeFactory().TryCreateType(typeof(SimpleEntity), cSpaceComplexType)); var factory = new Translator().TranslateColumnMap <object>( collectionMap, metadataWorkspaceMock.Object, new SpanIndex(), MergeOption.NoTracking, streaming: false, valueLayer: false); Assert.NotNull(factory); Assert.Equal(new[] { typeof(int), null }, factory.ColumnTypes); Assert.Equal(new[] { true, true }, factory.NullableColumns); }
public override void Visit(PhysicalProjectOp op, System.Data.Entity.Core.Query.InternalTrees.Node n) { this.VisitPhysicalOpDefault((PhysicalOp)op, n); this.Map(op.Outputs); SimpleCollectionColumnMap columnMap = (SimpleCollectionColumnMap)ColumnMapTranslator.Translate((ColumnMap)op.ColumnMap, this.m_varMap); n.Op = (Op)this.m_command.CreatePhysicalProjectOp(op.Outputs, columnMap); }
public override void Visit(PhysicalProjectOp op, Node n) { VisitPhysicalOpDefault(op, n); Map(op.Outputs); SimpleCollectionColumnMap newColumnMap = (SimpleCollectionColumnMap)ColumnMapTranslator.Translate(op.ColumnMap, m_varMap); n.Op = m_command.CreatePhysicalProjectOp(op.Outputs, newColumnMap); }
internal virtual void Visit(SimpleCollectionColumnMap columnMap, TArgType arg) { foreach (var fk in columnMap.ForeignKeys) { fk.Accept(this, arg); } foreach (var k in columnMap.Keys) { k.Accept(this, arg); } columnMap.Element.Accept(this, arg); }
/// <summary> /// SimpleCollectionColumnMap /// </summary> /// <param name="columnMap"></param> /// <param name="translationDelegate"></param> /// <returns></returns> internal override ColumnMap Visit(SimpleCollectionColumnMap columnMap, ColumnMapTranslatorTranslationDelegate translationDelegate) { VisitList(columnMap.ForeignKeys, translationDelegate); VisitList(columnMap.Keys, translationDelegate); ColumnMap newElement = columnMap.Element.Accept(this, translationDelegate); if (newElement != columnMap.Element) { columnMap = new SimpleCollectionColumnMap(columnMap.Type, columnMap.Name, newElement, columnMap.Keys, columnMap.ForeignKeys); } return(translationDelegate(columnMap)); }
internal virtual void Visit(SimpleCollectionColumnMap columnMap, TArgType arg) { foreach (ColumnMap foreignKey in columnMap.ForeignKeys) { foreignKey.Accept <TArgType>(this, arg); } foreach (ColumnMap key in columnMap.Keys) { key.Accept <TArgType>(this, arg); } columnMap.Element.Accept <TArgType>(this, arg); }
/// <summary> /// Creates a column map for the given reader and function mapping. /// </summary> internal virtual CollectionColumnMap CreateFunctionImportStructuralTypeColumnMap( DbDataReader storeDataReader, FunctionImportMappingNonComposable mapping, int resultSetIndex, EntitySet entitySet, StructuralType baseStructuralType) { var resultMapping = mapping.GetResultMapping(resultSetIndex); Debug.Assert(resultMapping != null); if (resultMapping.NormalizedEntityTypeMappings.Count == 0) // no explicit mapping; use default non-polymorphic reader { // if there is no mapping, create default mapping to root entity type or complex type Debug.Assert(!baseStructuralType.Abstract, "mapping loader must verify abstract types have explicit mapping"); return CreateColumnMapFromReaderAndType( storeDataReader, baseStructuralType, entitySet, resultMapping.ReturnTypeColumnsRenameMapping); } // the section below deals with the polymorphic entity type mapping for return type var baseEntityType = baseStructuralType as EntityType; Debug.Assert(null != baseEntityType, "We should have entity type here"); // Generate column maps for all discriminators var discriminatorColumns = CreateDiscriminatorColumnMaps(storeDataReader, mapping, resultSetIndex); // Generate default maps for all mapped entity types var mappedEntityTypes = new HashSet<EntityType>(resultMapping.MappedEntityTypes); mappedEntityTypes.Add(baseEntityType); // make sure the base type is represented var typeChoices = new Dictionary<EntityType, TypedColumnMap>(mappedEntityTypes.Count); ColumnMap[] baseTypeColumnMaps = null; foreach (var entityType in mappedEntityTypes) { var propertyColumnMaps = GetColumnMapsForType(storeDataReader, entityType, resultMapping.ReturnTypeColumnsRenameMapping); var entityColumnMap = CreateEntityTypeElementColumnMap( storeDataReader, entityType, entitySet, propertyColumnMaps, resultMapping.ReturnTypeColumnsRenameMapping); if (!entityType.Abstract) { typeChoices.Add(entityType, entityColumnMap); } if (entityType == baseStructuralType) { baseTypeColumnMaps = propertyColumnMaps; } } // NOTE: We don't have a null sentinel here, because the stored proc won't // return one anyway; we'll just presume the data's always there. var polymorphicMap = new MultipleDiscriminatorPolymorphicColumnMap( TypeUsage.Create(baseStructuralType), baseStructuralType.Name, baseTypeColumnMaps, discriminatorColumns, typeChoices, (object[] discriminatorValues) => mapping.Discriminate(discriminatorValues, resultSetIndex)); CollectionColumnMap collection = new SimpleCollectionColumnMap( baseStructuralType.GetCollectionType().TypeUsage, baseStructuralType.Name, polymorphicMap, null, null); return collection; }
internal override ColumnMap Visit( SimpleCollectionColumnMap columnMap, ColumnMapTranslatorTranslationDelegate translationDelegate) { this.VisitList <SimpleColumnMap>(columnMap.ForeignKeys, translationDelegate); this.VisitList <SimpleColumnMap>(columnMap.Keys, translationDelegate); ColumnMap elementMap = columnMap.Element.Accept <ColumnMap, ColumnMapTranslatorTranslationDelegate>((ColumnMapVisitorWithResults <ColumnMap, ColumnMapTranslatorTranslationDelegate>) this, translationDelegate); if (elementMap != columnMap.Element) { columnMap = new SimpleCollectionColumnMap(columnMap.Type, columnMap.Name, elementMap, columnMap.Keys, columnMap.ForeignKeys); } return(translationDelegate((ColumnMap)columnMap)); }
public void TranslateColumnMap_with_MultipleDiscriminatorPolymorphicColumnMap_returns_a_ShaperFactory() { var polymorphicMap = new MultipleDiscriminatorPolymorphicColumnMap( new Mock<TypeUsage>().Object, "MockType", new ColumnMap[0], new SimpleColumnMap[0], new Dictionary<EntityType, TypedColumnMap>(), discriminatorValues => new EntityType("E", "N", DataSpace.CSpace)); CollectionColumnMap collection = new SimpleCollectionColumnMap( new Mock<TypeUsage>().Object, "MockCollectionType", polymorphicMap, null, null); var metadataWorkspaceMock = new Mock<MetadataWorkspace>(); metadataWorkspaceMock.Setup(m => m.GetQueryCacheManager()).Returns(QueryCacheManager.Create()); Assert.NotNull( new Translator().TranslateColumnMap<object>( collection, metadataWorkspaceMock.Object, new SpanIndex(), MergeOption.NoTracking, streaming: true, valueLayer: false)); }
public void TranslateColumnMap_with_MultipleDiscriminatorPolymorphicColumnMap_returns_a_ShaperFactory() { var polymorphicMap = new MultipleDiscriminatorPolymorphicColumnMap( new Mock <TypeUsage>().Object, "MockType", new ColumnMap[0], new SimpleColumnMap[0], new Dictionary <EntityType, TypedColumnMap>(), discriminatorValues => new EntityType("E", "N", DataSpace.CSpace)); CollectionColumnMap collection = new SimpleCollectionColumnMap( new Mock <TypeUsage>().Object, "MockCollectionType", polymorphicMap, null, null); var metadataWorkspaceMock = new Mock <MetadataWorkspace>(); metadataWorkspaceMock.Setup(m => m.GetQueryCacheManager()).Returns(QueryCacheManager.Create()); Assert.NotNull( new Translator().TranslateColumnMap <object>( collection, metadataWorkspaceMock.Object, new SpanIndex(), MergeOption.NoTracking, streaming: true, valueLayer: false)); }
public void TranslateColumnMap_returns_correct_columntypes_and_nullablecolumns_for_entity_types() { var metadataWorkspaceMock = new Mock <MetadataWorkspace>(); metadataWorkspaceMock.Setup(m => m.GetQueryCacheManager()).Returns(QueryCacheManager.Create()); var cSpaceEntityType = new EntityType(typeof(ManyTypesEntity).Name, "N", DataSpace.CSpace); cSpaceEntityType.AddMember( new EdmProperty("P1Bool", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Boolean), new FacetValues { Nullable = false }))); cSpaceEntityType.AddMember( new EdmProperty("P2NullableBool", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Boolean), new FacetValues { Nullable = true }))); cSpaceEntityType.AddMember( new EdmProperty("P3ByteArray", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Binary)))); cSpaceEntityType.AddMember( new EdmProperty("P4Timespan", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Time), new FacetValues { Nullable = false }))); cSpaceEntityType.AddMember( new EdmProperty("P5NullableTimespan", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Time), new FacetValues { Nullable = true }))); var enumType = new EnumType( "DayOfWeek", "N", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), false, DataSpace.CSpace); cSpaceEntityType.AddMember( new EdmProperty("P6Enum", TypeUsage.Create(enumType, new FacetValues { Nullable = false }))); cSpaceEntityType.AddMember( new EdmProperty("P7NullableEnum", TypeUsage.Create(enumType, new FacetValues { Nullable = true }))); var entityTypeUsage = TypeUsage.Create(cSpaceEntityType); cSpaceEntityType.AddMember( new EdmProperty("P8Geography", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Geography)))); var oSpaceTypeFactory = new CodeFirstOSpaceTypeFactory(); var oSpaceEntityType = oSpaceTypeFactory.TryCreateType(typeof(ManyTypesEntity), cSpaceEntityType); oSpaceTypeFactory.CspaceToOspace.Add(enumType, oSpaceTypeFactory.TryCreateType(typeof(DayOfWeek), enumType)); foreach (var resolve in oSpaceTypeFactory.ReferenceResolutions) { resolve(); } var scalarMaps = new List <ScalarColumnMap>(); foreach (var edmProperty in cSpaceEntityType.Properties) { scalarMaps.Add(new ScalarColumnMap(edmProperty.TypeUsage, edmProperty.Name, 0, scalarMaps.Count)); } var entityMap = new EntityColumnMap( entityTypeUsage, "E", scalarMaps.ToArray(), new SimpleEntityIdentity(null, new SimpleColumnMap[] { scalarMaps[0] })); var collectionMap = new SimpleCollectionColumnMap( entityTypeUsage, "MockCollectionType", entityMap, null, null); metadataWorkspaceMock.Setup(m => m.GetItem <EdmType>(It.IsAny <string>(), DataSpace.OSpace)) .Returns(oSpaceEntityType); var factory = new Translator().TranslateColumnMap <object>( collectionMap, metadataWorkspaceMock.Object, new SpanIndex(), MergeOption.NoTracking, streaming: false, valueLayer: false); Assert.NotNull(factory); Assert.Equal( new[] { typeof(bool), typeof(bool), typeof(byte[]), typeof(TimeSpan), typeof(TimeSpan), typeof(int), typeof(int), typeof(DbGeography) }, factory.ColumnTypes); // The first column is nullable as it's part of the key Assert.Equal(new[] { true, true, true, false, true, false, true, true }, factory.NullableColumns); }
/// <summary> /// Requires: a public type with a public, default constructor. Returns a column map initializing the type /// and all properties of the type with a public setter taking a primitive type and having a corresponding /// column in the reader. /// </summary> internal static CollectionColumnMap CreateColumnMapFromReaderAndClrType(DbDataReader reader, Type type, MetadataWorkspace workspace) { Debug.Assert(null != reader); Debug.Assert(null != type); Debug.Assert(null != workspace); // we require a default constructor ConstructorInfo constructor = type.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, Type.EmptyTypes, null); if (type.IsAbstract || (null == constructor && !type.IsValueType)) { throw EntityUtil.InvalidOperation( Strings.ObjectContext_InvalidTypeForStoreQuery(type)); } // build a LINQ expression used by result assembly to create results var memberInfo = new List<Tuple<MemberAssignment, int, EdmProperty>>(); foreach (PropertyInfo prop in type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)) { // for enums unwrap the type if nullable var propertyUnderlyingType = Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType; Type propType = propertyUnderlyingType.IsEnum ? propertyUnderlyingType.GetEnumUnderlyingType() : prop.PropertyType; EdmType modelType; int ordinal; if (TryGetColumnOrdinalFromReader(reader, prop.Name, out ordinal) && MetadataHelper.TryDetermineCSpaceModelType(propType, workspace, out modelType) && (Helper.IsScalarType(modelType)) && prop.CanWrite && prop.GetIndexParameters().Length == 0 && null != prop.GetSetMethod(/* nonPublic */true)) { memberInfo.Add(Tuple.Create( Expression.Bind(prop, Expression.Parameter(prop.PropertyType, "placeholder")), ordinal, new EdmProperty(prop.Name, TypeUsage.Create(modelType)))); } } // initialize members in the order in which they appear in the reader MemberInfo[] members = new MemberInfo[memberInfo.Count]; MemberBinding[] memberBindings = new MemberBinding[memberInfo.Count]; ColumnMap[] propertyMaps = new ColumnMap[memberInfo.Count]; EdmProperty[] modelProperties = new EdmProperty[memberInfo.Count]; int i = 0; foreach (var memberGroup in memberInfo.GroupBy(tuple => tuple.Item2).OrderBy(tuple => tuple.Key)) { // make sure that a single column isn't contributing to multiple properties if (memberGroup.Count() != 1) { throw EntityUtil.InvalidOperation(Strings.ObjectContext_TwoPropertiesMappedToSameColumn( reader.GetName(memberGroup.Key), String.Join(", ", memberGroup.Select(tuple => tuple.Item3.Name).ToArray()))); } var member = memberGroup.Single(); MemberAssignment assignment = member.Item1; int ordinal = member.Item2; EdmProperty modelProp = member.Item3; members[i] = assignment.Member; memberBindings[i] = assignment; propertyMaps[i] = new ScalarColumnMap(modelProp.TypeUsage, modelProp.Name, 0, ordinal); modelProperties[i] = modelProp; i++; } NewExpression newExpr = null == constructor ? Expression.New(type) : Expression.New(constructor); MemberInitExpression init = Expression.MemberInit(newExpr, memberBindings); InitializerMetadata initMetadata = InitializerMetadata.CreateProjectionInitializer( (EdmItemCollection)workspace.GetItemCollection(DataSpace.CSpace), init, members); // column map (a collection of rows with InitializerMetadata markup) RowType rowType = new RowType(modelProperties, initMetadata); RecordColumnMap rowMap = new RecordColumnMap(TypeUsage.Create(rowType), "DefaultTypeProjection", propertyMaps, null); CollectionColumnMap collectionMap = new SimpleCollectionColumnMap(rowType.GetCollectionType().TypeUsage, rowType.Name, rowMap, null, null); return collectionMap; }
public override Node Visit(PhysicalProjectOp op, Node n) { // cannot be multi-input (not at this point) PlanCompiler.Assert(n.Children.Count == 1, "multiple inputs to physicalProject?"); // First visit my children VisitChildren(n); m_varRemapper.RemapNode(n); // Wait until we're processing the root physicalProjectNode to convert the nestOp // to sort/union all; it's much easier to unnest them if we don't monkey with them // until then. // // Also, even if we're the root physicalProjectNode and the children aren't NestOps, // then there's nothing further to do. if (n != Command.Root || !IsNestOpNode(n.Child0)) { return n; } #if DEBUG var input = Dump.ToXml(n); #endif //DEBUG var nestNode = n.Child0; // OK, we're now guaranteed to be processing a root physicalProjectNode with at // least one MultiStreamNestOp as it's input. First step is to convert that into // a single SingleStreamNestOp. // // NOTE: if we ever wanted to support MARS, we would probably avoid the conversion // to SingleStreamNest here, and do something to optimize this a bit // differently for MARS. But that's a future feature. var varRefReplacementMap = new Dictionary<Var, ColumnMap>(); //Dev10_579146: The parameters that are output should be retained. var outputVars = Command.CreateVarList(op.Outputs.Where(v => v.VarType == VarType.Parameter)); SimpleColumnMap[] keyColumnMaps; nestNode = ConvertToSingleStreamNest(nestNode, varRefReplacementMap, outputVars, out keyColumnMaps); var ssnOp = (SingleStreamNestOp)nestNode.Op; // Build up the sort node (if necessary). var sortNode = BuildSortForNestElimination(ssnOp, nestNode); // Create a new column map using the columnMapPatcher that was updated by the // conversion to SingleStreamNest process. var newProjectColumnMap = (SimpleCollectionColumnMap)ColumnMapTranslator.Translate(((PhysicalProjectOp)n.Op).ColumnMap, varRefReplacementMap); newProjectColumnMap = new SimpleCollectionColumnMap( newProjectColumnMap.Type, newProjectColumnMap.Name, newProjectColumnMap.Element, keyColumnMaps, null); // Ok, build the new PhysicalProjectOp, slap the sortNode as its input // and we're all done. n.Op = Command.CreatePhysicalProjectOp(outputVars, newProjectColumnMap); n.Child0 = sortNode; #if DEBUG var size = input.Length; // GC.KeepAlive makes FxCop Grumpy. var output = Dump.ToXml(n); #endif //DEBUG return n; }
/// <summary> /// Build the collectionColumnMap from a store datareader, a type and an entitySet. /// </summary> /// <param name="storeDataReader"></param> /// <param name="edmType"></param> /// <param name="entitySet"></param> /// <returns></returns> internal static CollectionColumnMap CreateColumnMapFromReaderAndType(DbDataReader storeDataReader, EdmType edmType, EntitySet entitySet, Dictionary<string, FunctionImportReturnTypeStructuralTypeColumnRenameMapping> renameList) { Debug.Assert(Helper.IsEntityType(edmType) || null == entitySet, "The specified non-null EntitySet is incompatible with the EDM type specified."); // Next, build the ColumnMap directly from the edmType and entitySet provided. ColumnMap[] propertyColumnMaps = GetColumnMapsForType(storeDataReader, edmType, renameList); ColumnMap elementColumnMap = null; // NOTE: We don't have a null sentinel here, because the stored proc won't // return one anyway; we'll just presume the data's always there. if (Helper.IsRowType(edmType)) { elementColumnMap = new RecordColumnMap(TypeUsage.Create(edmType), edmType.Name, propertyColumnMaps, null); } else if (Helper.IsComplexType(edmType)) { elementColumnMap = new ComplexTypeColumnMap(TypeUsage.Create(edmType), edmType.Name, propertyColumnMaps, null); } else if (Helper.IsScalarType(edmType)) { if (storeDataReader.FieldCount != 1) { throw EntityUtil.CommandExecutionDataReaderFieldCountForScalarType(); } elementColumnMap = new ScalarColumnMap(TypeUsage.Create(edmType), edmType.Name, 0, 0); } else if (Helper.IsEntityType(edmType)) { elementColumnMap = CreateEntityTypeElementColumnMap(storeDataReader, edmType, entitySet, propertyColumnMaps, null/*renameList*/); } else { Debug.Assert(false, "unexpected edmType?"); } CollectionColumnMap collection = new SimpleCollectionColumnMap(edmType.GetCollectionType().TypeUsage, edmType.Name, elementColumnMap, null, null); return collection; }
/// <summary> /// Create a PhysicalProjectOp - with a columnMap describing the output /// </summary> /// <param name="outputVars">list of output vars</param> /// <param name="columnMap">columnmap describing the output element</param> /// <returns></returns> internal PhysicalProjectOp CreatePhysicalProjectOp(VarList outputVars, SimpleCollectionColumnMap columnMap) { return new PhysicalProjectOp(outputVars, columnMap); }
private SimpleCollectionColumnMap ExpandColumnMap(SimpleCollectionColumnMap columnMap) { var varRefColumnMap = columnMap.Element as VarRefColumnMap; PlanCompiler.Assert( varRefColumnMap != null, "Encountered a SimpleCollectionColumnMap element that is not VarRefColumnMap when expanding a column map in NominalTypeEliminator."); // see if this var has changed in some fashion VarInfo varInfo; if (!m_varInfoMap.TryGetVarInfo(varRefColumnMap.Var, out varInfo)) { return columnMap; // no changes } // // Ensure that we get the right number of Vars - we need one Var for // each scalar property // if (TypeUtils.IsStructuredType(varRefColumnMap.Var.Type)) { var typeInfo = m_typeInfo.GetTypeInfo(varRefColumnMap.Var.Type); PlanCompiler.Assert( typeInfo.RootType.FlattenedType.Properties.Count == varInfo.NewVars.Count, "Var count mismatch; Expected " + typeInfo.RootType.FlattenedType.Properties.Count + "; got " + varInfo.NewVars.Count + " instead."); } // "Process" this columnMap var processor = new ColumnMapProcessor(varRefColumnMap, varInfo, m_typeInfo); var newColumnMap = processor.ExpandColumnMap(); //Wrap it with a collection var resultColumnMap = new SimpleCollectionColumnMap( TypeUtils.CreateCollectionType(newColumnMap.Type), newColumnMap.Name, newColumnMap, columnMap.Keys, columnMap.ForeignKeys); return resultColumnMap; }
private static ObjectContext CreateObjectContext(DbCommand dbCommand) { var metadataWorkspaceMock = new Mock<MetadataWorkspace> { CallBase = true }; var edmItemCollection = new EdmItemCollection(); var providerManifestMock = new Mock<DbProviderManifest>(); providerManifestMock.Setup(m => m.GetStoreTypes()).Returns(new ReadOnlyCollection<PrimitiveType>(new List<PrimitiveType>())); providerManifestMock.Setup(m => m.GetStoreFunctions()).Returns(new ReadOnlyCollection<EdmFunction>(new List<EdmFunction>())); var storeItemCollection = new StoreItemCollection( FakeSqlProviderFactory.Instance, providerManifestMock.Object, GenericProviderFactory<DbProviderFactory>.Instance.InvariantProviderName, "2008"); metadataWorkspaceMock.Setup(m => m.GetItemCollection(DataSpace.OSpace, It.IsAny<bool>())) .Returns(new ObjectItemCollection()); metadataWorkspaceMock.Setup(m => m.GetItemCollection(DataSpace.OCSpace, It.IsAny<bool>())) .Returns(new ObjectItemCollection()); metadataWorkspaceMock.Setup(m => m.GetItemCollection(DataSpace.CSpace, It.IsAny<bool>())) .Returns(edmItemCollection); metadataWorkspaceMock.Setup(m => m.GetItemCollection(DataSpace.SSpace, It.IsAny<bool>())) .Returns(storeItemCollection); metadataWorkspaceMock.Setup(m => m.GetItemCollection(DataSpace.CSSpace, It.IsAny<bool>())) .Returns(new StorageMappingItemCollection(edmItemCollection, storeItemCollection)); metadataWorkspaceMock.Setup(m => m.GetQueryCacheManager()).Returns(QueryCacheManager.Create()); var translator = Common.Internal.Materialization.MockHelper.CreateTranslator<object>(); var edmTypeMock = new Mock<EdmType>(); edmTypeMock.Setup(m => m.BuiltInTypeKind).Returns(BuiltInTypeKind.SimpleType); var collectionColumnMap = new SimpleCollectionColumnMap( TypeUsage.Create(edmTypeMock.Object), "", new ScalarColumnMap(TypeUsage.Create(edmTypeMock.Object), "", 0, 0), null, null); var objectStateManagerMock = new Mock<ObjectStateManager>(); var columnMapFactoryMock = new Mock<ColumnMapFactory>(); columnMapFactoryMock.Setup( m => m.CreateColumnMapFromReaderAndType( It.IsAny<DbDataReader>(), It.IsAny<EdmType>(), It.IsAny<EntitySet>(), It.IsAny<Dictionary<string, FunctionImportReturnTypeStructuralTypeColumnRenameMapping>>())) .Returns(collectionColumnMap); columnMapFactoryMock.Setup( m => m.CreateColumnMapFromReaderAndClrType(It.IsAny<DbDataReader>(), It.IsAny<Type>(), It.IsAny<MetadataWorkspace>())) .Returns(collectionColumnMap); return CreateObjectContext( objectStateManagerMock: objectStateManagerMock, metadataWorkspaceMock: metadataWorkspaceMock, translator: translator, columnMapFactory: columnMapFactoryMock.Object, dbCommand: dbCommand); }
public void TranslateColumnMap_returns_correct_columntypes_and_nullablecolumns_for_associations() { var metadataWorkspaceMock = new Mock <MetadataWorkspace>(); metadataWorkspaceMock.Setup(m => m.GetQueryCacheManager()).Returns(QueryCacheManager.Create()); var codeFirstOSpaceTypeFactory = new CodeFirstOSpaceTypeFactory(); var refEntityColumnMap = (EntityColumnMap)BuildSimpleEntitySetColumnMap(metadataWorkspaceMock, codeFirstOSpaceTypeFactory).Element; var cSpaceEntityType = new EntityType(typeof(RefEntity).Name, "N", DataSpace.CSpace); cSpaceEntityType.AddMember(new EdmProperty("Id", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)))); var navigationProperty = new NavigationProperty("SimpleEntity", TypeUsage.Create(refEntityColumnMap.Type.EdmType)); var associationType = new AssociationType("A", "N", false, DataSpace.CSpace); associationType.AddMember( new AssociationEndMember("From", new RefType(cSpaceEntityType), RelationshipMultiplicity.One)); associationType.AddMember( new AssociationEndMember("To", new RefType((EntityType)navigationProperty.TypeUsage.EdmType), RelationshipMultiplicity.One)); associationType.SetReadOnly(); navigationProperty.RelationshipType = associationType; navigationProperty.FromEndMember = associationType.RelationshipEndMembers[0]; navigationProperty.ToEndMember = associationType.RelationshipEndMembers[1]; cSpaceEntityType.AddMember(navigationProperty); var entityTypeUsage = TypeUsage.Create(cSpaceEntityType); var oSpaceEntityType = codeFirstOSpaceTypeFactory.TryCreateType(typeof(RefEntity), cSpaceEntityType); codeFirstOSpaceTypeFactory.CspaceToOspace.Add(cSpaceEntityType, oSpaceEntityType); var associations = new EdmItemCollection(); associations.AddInternal(associationType); codeFirstOSpaceTypeFactory.CreateRelationships(associations); foreach (var resolve in codeFirstOSpaceTypeFactory.ReferenceResolutions) { resolve(); } var idScalarMap = new ScalarColumnMap(TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)), "Id", 0, 1); var refColumnMap = new RefColumnMap( associationType.RelationshipEndMembers[1].TypeUsage, "E", new SimpleEntityIdentity(null, new SimpleColumnMap[] { idScalarMap })); var collectionMap = new SimpleCollectionColumnMap( entityTypeUsage, "MockCollectionType", refColumnMap, null, null); metadataWorkspaceMock.Setup(m => m.GetItem <EdmType>("N.RefEntity", DataSpace.OSpace)) .Returns(oSpaceEntityType); var factory = new Translator().TranslateColumnMap <object>( collectionMap, metadataWorkspaceMock.Object, new SpanIndex(), MergeOption.NoTracking, streaming: false, valueLayer: false); Assert.NotNull(factory); Assert.Equal(new[] { null, typeof(int) }, factory.ColumnTypes); Assert.Equal(new[] { false, true }, factory.NullableColumns); }
public void TranslateColumnMap_returns_correct_columntypes_and_nullablecolumns_for_associations() { var metadataWorkspaceMock = new Mock<MetadataWorkspace>(); metadataWorkspaceMock.Setup(m => m.GetQueryCacheManager()).Returns(QueryCacheManager.Create()); var codeFirstOSpaceTypeFactory = new CodeFirstOSpaceTypeFactory(); var refEntityColumnMap = (EntityColumnMap)BuildSimpleEntitySetColumnMap(metadataWorkspaceMock, codeFirstOSpaceTypeFactory).Element; var cSpaceEntityType = new EntityType(typeof(RefEntity).Name, "N", DataSpace.CSpace); cSpaceEntityType.AddMember(new EdmProperty("Id", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)))); var navigationProperty = new NavigationProperty("SimpleEntity", TypeUsage.Create(refEntityColumnMap.Type.EdmType)); var associationType = new AssociationType("A", "N", false, DataSpace.CSpace); associationType.AddMember( new AssociationEndMember("From", new RefType(cSpaceEntityType), RelationshipMultiplicity.One)); associationType.AddMember( new AssociationEndMember("To", new RefType((EntityType)navigationProperty.TypeUsage.EdmType), RelationshipMultiplicity.One)); associationType.SetReadOnly(); navigationProperty.RelationshipType = associationType; navigationProperty.FromEndMember = associationType.RelationshipEndMembers[0]; navigationProperty.ToEndMember = associationType.RelationshipEndMembers[1]; cSpaceEntityType.AddMember(navigationProperty); var entityTypeUsage = TypeUsage.Create(cSpaceEntityType); var oSpaceEntityType = codeFirstOSpaceTypeFactory.TryCreateType(typeof(RefEntity), cSpaceEntityType); codeFirstOSpaceTypeFactory.CspaceToOspace.Add(cSpaceEntityType, oSpaceEntityType); var associations = new EdmItemCollection(); associations.AddInternal(associationType); codeFirstOSpaceTypeFactory.CreateRelationships(associations); foreach (var resolve in codeFirstOSpaceTypeFactory.ReferenceResolutions) { resolve(); } var idScalarMap = new ScalarColumnMap(TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)), "Id", 0, 1); var refColumnMap = new RefColumnMap( associationType.RelationshipEndMembers[1].TypeUsage, "E", new SimpleEntityIdentity(null, new SimpleColumnMap[] { idScalarMap })); var collectionMap = new SimpleCollectionColumnMap( entityTypeUsage, "MockCollectionType", refColumnMap, null, null); metadataWorkspaceMock.Setup(m => m.GetItem<EdmType>("N.RefEntity", DataSpace.OSpace)) .Returns(oSpaceEntityType); var factory = new Translator().TranslateColumnMap<object>( collectionMap, metadataWorkspaceMock.Object, new SpanIndex(), MergeOption.NoTracking, streaming: false, valueLayer: false); Assert.NotNull(factory); Assert.Equal(new[] { null, typeof(int) }, factory.ColumnTypes); Assert.Equal(new[] { false, true }, factory.NullableColumns); }
/// <summary> /// Create a physicalProjectOp - with a single column output /// </summary> /// <param name="outputVar">the output element</param> /// <returns></returns> internal PhysicalProjectOp CreatePhysicalProjectOp(Var outputVar) { VarList varList = Command.CreateVarList(); varList.Add(outputVar); VarRefColumnMap varRefColumnMap = new VarRefColumnMap(outputVar); SimpleCollectionColumnMap collectionColumnMap = new SimpleCollectionColumnMap( TypeUtils.CreateCollectionType(varRefColumnMap.Type), // type null, // name varRefColumnMap, // element map new SimpleColumnMap[0], // keys new SimpleColumnMap[0]); // foreign keys return CreatePhysicalProjectOp(varList, collectionColumnMap); }
public void TranslateColumnMap_returns_correct_columntypes_and_nullablecolumns_for_complex_types() { var metadataWorkspaceMock = new Mock<MetadataWorkspace>(); metadataWorkspaceMock.Setup(m => m.GetQueryCacheManager()).Returns(QueryCacheManager.Create()); var cSpaceComplexType = new ComplexType("C"); var intTypeUsage = TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), new FacetValues { Nullable = false }); cSpaceComplexType.AddMember(new EdmProperty("Id", intTypeUsage)); cSpaceComplexType.AddMember(new EdmProperty("Count", intTypeUsage)); var complexTypeUsage = TypeUsage.Create(cSpaceComplexType); var recordMap = new ComplexTypeColumnMap( complexTypeUsage, "E", new[] { new ScalarColumnMap(cSpaceComplexType.Properties[0].TypeUsage, cSpaceComplexType.Properties[0].Name, 0, 0) }, new ScalarColumnMap(cSpaceComplexType.Properties[1].TypeUsage, cSpaceComplexType.Properties[1].Name, 0, 1)); var collectionMap = new SimpleCollectionColumnMap( complexTypeUsage, "MockCollectionType", recordMap, null, null); metadataWorkspaceMock.Setup(m => m.GetItem<EdmType>(It.IsAny<string>(), DataSpace.OSpace)) .Returns(new CodeFirstOSpaceTypeFactory().TryCreateType(typeof(SimpleEntity), cSpaceComplexType)); var factory = new Translator().TranslateColumnMap<object>( collectionMap, metadataWorkspaceMock.Object, new SpanIndex(), MergeOption.NoTracking, streaming: false, valueLayer: false); Assert.NotNull(factory); Assert.Equal(new[] { typeof(int), null }, factory.ColumnTypes); Assert.Equal(new[] { true, true }, factory.NullableColumns); }
public void TranslateColumnMap_returns_correct_columntypes_and_nullablecolumns_for_discriminated_types() { var metadataWorkspaceMock = new Mock<MetadataWorkspace>(); metadataWorkspaceMock.Setup(m => m.GetQueryCacheManager()).Returns(QueryCacheManager.Create()); var typeChoices = new Dictionary<object, TypedColumnMap>(); var entityColumnMap = (EntityColumnMap)BuildSimpleEntitySetColumnMap(metadataWorkspaceMock).Element; typeChoices.Add(true, entityColumnMap); var recordMap = new SimplePolymorphicColumnMap( entityColumnMap.Type, "E", new ColumnMap[0], new ScalarColumnMap(TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Boolean)), "discriminator", 0, 2), typeChoices); var collectionMap = new SimpleCollectionColumnMap( entityColumnMap.Type, "MockCollectionType", recordMap, null, null); var factory = new Translator().TranslateColumnMap<object>( collectionMap, metadataWorkspaceMock.Object, new SpanIndex(), MergeOption.NoTracking, streaming: false, valueLayer: false); Assert.NotNull(factory); Assert.Equal(new[] { typeof(int), typeof(int), typeof(bool) }, factory.ColumnTypes); Assert.Equal(new[] { true, true, true }, factory.NullableColumns); }
/// <summary> /// Determines the store type for a function import. /// </summary> private TypeUsage DetermineStoreResultType(MetadataWorkspace workspace, FunctionImportMappingNonComposable mapping, int resultSetIndex, out IColumnMapGenerator columnMapGenerator) { // Determine column maps and infer result types for the mapped function. There are four varieties: // Collection(Entity) // Collection(PrimitiveType) // Collection(ComplexType) // No result type TypeUsage storeResultType; { StructuralType baseStructuralType; EdmFunction functionImport = mapping.FunctionImport; // Collection(Entity) or Collection(ComplexType) if (MetadataHelper.TryGetFunctionImportReturnType<StructuralType>(functionImport, resultSetIndex, out baseStructuralType)) { ValidateEdmResultType(baseStructuralType, functionImport); //Note: Defensive check for historic reasons, we expect functionImport.EntitySets.Count > resultSetIndex EntitySet entitySet = functionImport.EntitySets.Count > resultSetIndex ? functionImport.EntitySets[resultSetIndex] : null; columnMapGenerator = new FunctionColumnMapGenerator(mapping, resultSetIndex, entitySet, baseStructuralType); // We don't actually know the return type for the stored procedure, but we can infer // one based on the mapping (i.e.: a column for every property of the mapped types // and for all discriminator columns) storeResultType = mapping.GetExpectedTargetResultType(workspace, resultSetIndex); } // Collection(PrimitiveType) else { FunctionParameter returnParameter = MetadataHelper.GetReturnParameter(functionImport, resultSetIndex); if (returnParameter != null && returnParameter.TypeUsage != null) { // Get metadata description of the return type storeResultType = returnParameter.TypeUsage; Debug.Assert(storeResultType.EdmType.BuiltInTypeKind == BuiltInTypeKind.CollectionType, "FunctionImport currently supports only collection result type"); TypeUsage elementType = ((CollectionType)storeResultType.EdmType).TypeUsage; Debug.Assert(Helper.IsScalarType(elementType.EdmType) , "FunctionImport supports only Collection(Entity), Collection(Enum) and Collection(Primitive)"); // Build collection column map where the first column of the store result is assumed // to contain the primitive type values. ScalarColumnMap scalarColumnMap = new ScalarColumnMap(elementType, string.Empty, 0, 0); SimpleCollectionColumnMap collectionColumnMap = new SimpleCollectionColumnMap(storeResultType, string.Empty, scalarColumnMap, null, null); columnMapGenerator = new ConstantColumnMapGenerator(collectionColumnMap, 1); } // No result type else { storeResultType = null; columnMapGenerator = new ConstantColumnMapGenerator(null, 0); } } } return storeResultType; }
internal override void Visit(SimpleCollectionColumnMap columnMap, int dummy) { Append("DC-FK", columnMap.ForeignKeys); Append(",K", columnMap.Keys); Append(",E", columnMap.Element); }
internal abstract TResultType Visit(SimpleCollectionColumnMap columnMap, TArgType arg);
public void TranslateColumnMap_returns_correct_columntypes_and_nullablecolumns_for_entity_types() { var metadataWorkspaceMock = new Mock<MetadataWorkspace>(); metadataWorkspaceMock.Setup(m => m.GetQueryCacheManager()).Returns(QueryCacheManager.Create()); var cSpaceEntityType = new EntityType(typeof(ManyTypesEntity).Name, "N", DataSpace.CSpace); cSpaceEntityType.AddMember( new EdmProperty("P1Bool", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Boolean), new FacetValues { Nullable = false }))); cSpaceEntityType.AddMember( new EdmProperty("P2NullableBool", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Boolean), new FacetValues { Nullable = true }))); cSpaceEntityType.AddMember( new EdmProperty("P3ByteArray", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Binary)))); cSpaceEntityType.AddMember( new EdmProperty("P4Timespan", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Time), new FacetValues { Nullable = false }))); cSpaceEntityType.AddMember( new EdmProperty("P5NullableTimespan", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Time), new FacetValues { Nullable = true }))); var enumType = new EnumType( "DayOfWeek", "N", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), false, DataSpace.CSpace); cSpaceEntityType.AddMember( new EdmProperty("P6Enum", TypeUsage.Create(enumType, new FacetValues { Nullable = false }))); cSpaceEntityType.AddMember( new EdmProperty("P7NullableEnum", TypeUsage.Create(enumType, new FacetValues { Nullable = true }))); var entityTypeUsage = TypeUsage.Create(cSpaceEntityType); cSpaceEntityType.AddMember( new EdmProperty("P8Geography", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Geography)))); var oSpaceTypeFactory = new CodeFirstOSpaceTypeFactory(); var oSpaceEntityType = oSpaceTypeFactory.TryCreateType(typeof(ManyTypesEntity), cSpaceEntityType); oSpaceTypeFactory.CspaceToOspace.Add(enumType, oSpaceTypeFactory.TryCreateType(typeof(DayOfWeek), enumType)); foreach (var resolve in oSpaceTypeFactory.ReferenceResolutions) { resolve(); } var scalarMaps = new List<ScalarColumnMap>(); foreach (var edmProperty in cSpaceEntityType.Properties) { scalarMaps.Add(new ScalarColumnMap(edmProperty.TypeUsage, edmProperty.Name, 0, scalarMaps.Count)); } var entityMap = new EntityColumnMap( entityTypeUsage, "E", scalarMaps.ToArray(), new SimpleEntityIdentity(null, new SimpleColumnMap[] { scalarMaps[0] })); var collectionMap = new SimpleCollectionColumnMap( entityTypeUsage, "MockCollectionType", entityMap, null, null); metadataWorkspaceMock.Setup(m => m.GetItem<EdmType>(It.IsAny<string>(), DataSpace.OSpace)) .Returns(oSpaceEntityType); var factory = new Translator().TranslateColumnMap<object>( collectionMap, metadataWorkspaceMock.Object, new SpanIndex(), MergeOption.NoTracking, streaming: false, valueLayer: false); Assert.NotNull(factory); Assert.Equal( new[] { typeof(bool), typeof(bool), typeof(byte[]), typeof(TimeSpan), typeof(TimeSpan), typeof(int), typeof(int), typeof(DbGeography) }, factory.ColumnTypes); // The first column is nullable as it's part of the key Assert.Equal(new[] { true, true, true, false, true, false, true, true }, factory.NullableColumns); }
private SimpleCollectionColumnMap BuildSimpleEntitySetColumnMap(Mock<MetadataWorkspace> metadataWorkspaceMock, CodeFirstOSpaceTypeFactory codeFirstOSpaceTypeFactory = null) { var cSpaceEntityType = new EntityType(typeof(SimpleEntity).Name, "N", DataSpace.CSpace); var intTypeUsage = TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), new FacetValues{Nullable = false}); cSpaceEntityType.AddMember(new EdmProperty("Id", intTypeUsage)); cSpaceEntityType.AddMember(new EdmProperty("Count", intTypeUsage)); var entityTypeUsage = TypeUsage.Create(cSpaceEntityType); var idScalarMap = new ScalarColumnMap(intTypeUsage, "Id", 0, 0); var entityMap = new EntityColumnMap( entityTypeUsage, "E", new[] { idScalarMap, new ScalarColumnMap(intTypeUsage, "Count", 0, 1)}, new SimpleEntityIdentity(null, new SimpleColumnMap[] { idScalarMap })); var collectionMap = new SimpleCollectionColumnMap( entityTypeUsage, "MockCollectionType", entityMap, null, null); codeFirstOSpaceTypeFactory = codeFirstOSpaceTypeFactory ?? new CodeFirstOSpaceTypeFactory(); var oSpaceEntityType = codeFirstOSpaceTypeFactory.TryCreateType(typeof(SimpleEntity), cSpaceEntityType); codeFirstOSpaceTypeFactory.CspaceToOspace.Add(cSpaceEntityType, oSpaceEntityType); metadataWorkspaceMock.Setup(m => m.GetItem<EdmType>("N.SimpleEntity", DataSpace.OSpace)) .Returns(oSpaceEntityType); return collectionMap; }
public void TranslateColumnMap_returns_correct_columntypes_and_nullablecolumns_for_anonymous_types() { var metadataWorkspaceMock = new Mock<MetadataWorkspace>(); metadataWorkspaceMock.Setup(m => m.GetQueryCacheManager()).Returns(QueryCacheManager.Create()); var edmProperties = new [] { new EdmProperty("P1Int", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), new FacetValues { Nullable = false })), new EdmProperty("P2Bool", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Boolean))) }; var cSpaceEntityType = new RowType(edmProperties); var entityTypeUsage = TypeUsage.Create(cSpaceEntityType); var recordMap = new RecordColumnMap( entityTypeUsage, "E", new[] { new ScalarColumnMap(cSpaceEntityType.Properties[0].TypeUsage, cSpaceEntityType.Properties[0].Name, 0, 0) }, new ScalarColumnMap(cSpaceEntityType.Properties[1].TypeUsage, cSpaceEntityType.Properties[1].Name, 0, 1)); var collectionMap = new SimpleCollectionColumnMap( entityTypeUsage, "MockCollectionType", recordMap, null, null); var factory = new Translator().TranslateColumnMap<object>( collectionMap, metadataWorkspaceMock.Object, new SpanIndex(), MergeOption.NoTracking, streaming: false, valueLayer: false); Assert.NotNull(factory); Assert.Equal(new[] { typeof(int), null }, factory.ColumnTypes); Assert.Equal(new[] { true, true }, factory.NullableColumns); }
internal override void Visit(SimpleCollectionColumnMap columnMap, int dummy) { this.Append("DC-FK", (IEnumerable <ColumnMap>)columnMap.ForeignKeys); this.Append(",K", (IEnumerable <ColumnMap>)columnMap.Keys); this.Append(",E", columnMap.Element); }