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);
}
