protected virtual void Visit(EntityContainerMapping entityContainerMapping)
{
Visit(entityContainerMapping.EdmEntityContainer);
Visit(entityContainerMapping.StorageEntityContainer);
foreach (var mapping in GetSequence(entityContainerMapping.EntitySetMaps, it => IdentityHelper.GetIdentity(it)))
{
Visit(mapping);
}
}
internal static string GetMappingClosureHash(
double mappingVersion,
EntityContainerMapping entityContainerMapping,
bool sortSequence = true)
{
MetadataMappingHasherVisitor mappingHasherVisitor = new MetadataMappingHasherVisitor(mappingVersion, sortSequence);
mappingHasherVisitor.Visit(entityContainerMapping);
return(mappingHasherVisitor.HashValue);
}
public void Can_get_store_and_entity_containers()
{
var entityContainer = new EntityContainer("C", DataSpace.CSpace);
var storeContainer = new EntityContainer("S", DataSpace.CSpace);
var entityContainerMapping =
new EntityContainerMapping(entityContainer, storeContainer, null, false, false);
Assert.Same(entityContainer, entityContainerMapping.EdmEntityContainer);
Assert.Same(storeContainer, entityContainerMapping.StorageEntityContainer);
}
/// <summary>
/// Initialiazes a new EntitySetMapping instance.
/// </summary>
/// <param name="entitySet">The entity set to be mapped.</param>
/// <param name="containerMapping">The parent container mapping.</param>
public EntitySetMapping(EntitySet entitySet, EntityContainerMapping containerMapping)
: base(containerMapping)
{
Check.NotNull(entitySet, "entitySet");
_entitySet = entitySet;
_entityTypeMappings = new List <EntityTypeMapping>();
_modificationFunctionMappings = new List <EntityTypeModificationFunctionMapping>();
_implicitlyMappedAssociationSetEnds = new Lazy <List <AssociationSetEnd> >(
InitializeImplicitlyMappedAssociationSetEnds);
}
/// <summary>
/// Initializes a new FunctionImportMappingComposable instance.
/// </summary>
/// <param name="functionImport">The model function import.</param>
/// <param name="targetFunction">The store composable function.</param>
/// <param name="resultMapping">The result mapping for the function import.</param>
/// <param name="containerMapping">The parent container mapping.</param>
public FunctionImportMappingComposable(
EdmFunction functionImport,
EdmFunction targetFunction,
FunctionImportResultMapping resultMapping,
EntityContainerMapping containerMapping)
: base(Check.NotNull <EdmFunction>(functionImport, nameof(functionImport)), Check.NotNull <EdmFunction>(targetFunction, nameof(targetFunction)))
{
Check.NotNull <FunctionImportResultMapping>(resultMapping, nameof(resultMapping));
Check.NotNull <EntityContainerMapping>(containerMapping, nameof(containerMapping));
if (!functionImport.IsComposableAttribute)
{
throw new ArgumentException(Strings.NonComposableFunctionCannotBeMappedAsComposable((object)nameof(functionImport)));
}
if (!targetFunction.IsComposableAttribute)
{
throw new ArgumentException(Strings.NonComposableFunctionCannotBeMappedAsComposable((object)nameof(targetFunction)));
}
EdmType returnType;
if (!MetadataHelper.TryGetFunctionImportReturnType <EdmType>(functionImport, 0, out returnType))
{
throw new ArgumentException(Strings.InvalidReturnTypeForComposableFunction);
}
EdmFunction edmFunction = containerMapping.StorageMappingItemCollection != null?containerMapping.StorageMappingItemCollection.StoreItemCollection.ConvertToCTypeFunction(targetFunction) : StoreItemCollection.ConvertFunctionSignatureToCType(targetFunction);
RowType tvfReturnType1 = TypeHelpers.GetTvfReturnType(edmFunction);
RowType tvfReturnType2 = TypeHelpers.GetTvfReturnType(targetFunction);
if (tvfReturnType1 == null)
{
throw new ArgumentException(Strings.Mapping_FunctionImport_ResultMapping_InvalidSType((object)functionImport.Identity), nameof(functionImport));
}
List <EdmSchemaError> parsingErrors = new List <EdmSchemaError>();
FunctionImportMappingComposableHelper composableHelper = new FunctionImportMappingComposableHelper(containerMapping, string.Empty, parsingErrors);
FunctionImportMappingComposable mapping;
if (Helper.IsStructuralType(returnType))
{
composableHelper.TryCreateFunctionImportMappingComposableWithStructuralResult(functionImport, edmFunction, resultMapping.SourceList, tvfReturnType1, tvfReturnType2, (IXmlLineInfo)LineInfo.Empty, out mapping);
}
else
{
composableHelper.TryCreateFunctionImportMappingComposableWithScalarResult(functionImport, edmFunction, targetFunction, returnType, tvfReturnType1, (IXmlLineInfo)LineInfo.Empty, out mapping);
}
if (mapping == null)
{
throw new InvalidOperationException(parsingErrors.Count > 0 ? parsingErrors[0].Message : string.Empty);
}
this._containerMapping = mapping._containerMapping;
this.m_commandParameters = mapping.m_commandParameters;
this.m_structuralTypeMappings = mapping.m_structuralTypeMappings;
this.m_targetFunctionKeys = mapping.m_targetFunctionKeys;
this._resultMapping = resultMapping;
}
/// <summary>Initializes a new AssociationSetMapping instance.</summary>
/// <param name="associationSet">The association set to be mapped.</param>
/// <param name="storeEntitySet">The store entity set to be mapped.</param>
/// <param name="containerMapping">The parent container mapping.</param>
public AssociationSetMapping(
AssociationSet associationSet,
EntitySet storeEntitySet,
EntityContainerMapping containerMapping)
: base(containerMapping)
{
Check.NotNull <AssociationSet>(associationSet, nameof(associationSet));
Check.NotNull <EntitySet>(storeEntitySet, nameof(storeEntitySet));
this._associationSet = associationSet;
this._associationTypeMapping = new AssociationTypeMapping(associationSet.ElementType, this);
this._associationTypeMapping.MappingFragment = new MappingFragment(storeEntitySet, (TypeMapping)this._associationTypeMapping, false);
}
public void Cannot_add_type_mapping_when_read_only()
{
var entityContainerMapping = new EntityContainerMapping(new EntityContainer("C", DataSpace.CSpace));
var entitySetMapping = new EntitySetMapping(new EntitySet(), entityContainerMapping);
var entityTypeMapping = new EntityTypeMapping(entitySetMapping);
entitySetMapping.SetReadOnly();
Assert.Equal(
Strings.OperationOnReadOnlyItem,
Assert.Throws <InvalidOperationException>(
() => entitySetMapping.AddTypeMapping(entityTypeMapping)).Message);
}
internal FunctionImportMappingComposable(
EdmFunction functionImport,
EdmFunction targetFunction,
List <Tuple <StructuralType, List <ConditionPropertyMapping>, List <PropertyMapping> > > structuralTypeMappings,
EdmProperty[] targetFunctionKeys,
EntityContainerMapping containerMapping)
: base(functionImport, targetFunction)
{
this._containerMapping = containerMapping;
this.m_commandParameters = functionImport.Parameters.Select <FunctionParameter, DbParameterReferenceExpression>((Func <FunctionParameter, DbParameterReferenceExpression>)(p => TypeHelpers.GetPrimitiveTypeUsageForScalar(p.TypeUsage).Parameter(p.Name))).ToArray <DbParameterReferenceExpression>();
this.m_structuralTypeMappings = structuralTypeMappings;
this.m_targetFunctionKeys = targetFunctionKeys;
}
/// <summary>
/// Initializes a new FunctionImportMappingNonComposable instance.
/// </summary>
/// <param name="functionImport">The model function import.</param>
/// <param name="targetFunction">The store non-composable function.</param>
/// <param name="resultMappings">The function import result mappings.</param>
/// <param name="containerMapping">The parent container mapping.</param>
public FunctionImportMappingNonComposable(
EdmFunction functionImport,
EdmFunction targetFunction,
IEnumerable <FunctionImportResultMapping> resultMappings,
EntityContainerMapping containerMapping)
: base(
Check.NotNull(functionImport, "functionImport"),
Check.NotNull(targetFunction, "targetFunction"))
{
Check.NotNull(resultMappings, "resultMappings");
Check.NotNull(containerMapping, "containerMapping");
Debug.Assert(!functionImport.IsComposableAttribute);
Debug.Assert(!targetFunction.IsComposableAttribute);
if (!resultMappings.Any())
{
// when this method is invoked when a CodeFirst model is being built (e.g. from a custom convention) the
// StorageMappingItemCollection will be null. In this case we can provide an empty EdmItemCollection which
// will allow inferring implicit result mapping
var edmItemCollection = containerMapping.StorageMappingItemCollection != null
? containerMapping.StorageMappingItemCollection.EdmItemCollection
: new EdmItemCollection(new EdmModel(DataSpace.CSpace));
_internalResultMappings = new ReadOnlyCollection <FunctionImportStructuralTypeMappingKB>(
new[]
{
new FunctionImportStructuralTypeMappingKB(
new List <FunctionImportStructuralTypeMapping>(),
edmItemCollection)
});
noExplicitResultMappings = true;
}
else
{
Debug.Assert(functionImport.ReturnParameters.Count == resultMappings.Count());
_internalResultMappings = new ReadOnlyCollection <FunctionImportStructuralTypeMappingKB>(
resultMappings
.Select(
resultMapping => new FunctionImportStructuralTypeMappingKB(
resultMapping.TypeMappings,
containerMapping.StorageMappingItemCollection.EdmItemCollection))
.ToArray());
noExplicitResultMappings = false;
}
_resultMappings = new ReadOnlyCollection <FunctionImportResultMapping>(resultMappings.ToList());
}
public void Can_get_entity_type_mappings()
{
var entityContainerMapping = new EntityContainerMapping(new EntityContainer("C", DataSpace.CSpace));
var entitySetMapping = new EntitySetMapping(new EntitySet(), entityContainerMapping);
Assert.Empty(entitySetMapping.EntityTypeMappings);
var entityTypeMapping
= new EntityTypeMapping(
new EntitySetMapping(new EntitySet(), entityContainerMapping));
entitySetMapping.AddTypeMapping(entityTypeMapping);
Assert.Same(entityTypeMapping, entitySetMapping.EntityTypeMappings.Single());
}
public void Can_get_association_set_mappings()
{
var entityContainerMapping = new EntityContainerMapping(new EntityContainer("C", DataSpace.CSpace));
Assert.Empty(entityContainerMapping.AssociationSetMappings);
Assert.Empty(entityContainerMapping.RelationshipSetMaps);
var associationSetMapping
= new AssociationSetMapping(
new AssociationSet("AS", new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)), entityContainerMapping);
entityContainerMapping.AddSetMapping(associationSetMapping);
Assert.Same(associationSetMapping, entityContainerMapping.AssociationSetMappings.Single());
Assert.Same(associationSetMapping, entityContainerMapping.RelationshipSetMaps.Single());
}
public void Can_get_entity_set_mappings()
{
var entityContainerMapping = new EntityContainerMapping(new EntityContainer("C", DataSpace.CSpace));
Assert.Empty(entityContainerMapping.EntitySetMappings);
Assert.Empty(entityContainerMapping.EntitySetMaps);
var entitySetMapping
= new EntitySetMapping(
new EntitySet("ES", null, null, null, new EntityType("E", "N", DataSpace.CSpace)), entityContainerMapping);
entityContainerMapping.AddSetMapping(entitySetMapping);
Assert.Same(entitySetMapping, entityContainerMapping.EntitySetMappings.Single());
Assert.Same(entitySetMapping, entityContainerMapping.EntitySetMaps.Single());
}
public void Can_add_and_get_function_import_mapping()
{
var typeUsage =
TypeUsage.CreateDefaultTypeUsage(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32).GetCollectionType());
var entityContainerMapping = new EntityContainerMapping(new EntityContainer("C", DataSpace.CSpace));
var composableFunctionMapping =
new FunctionImportMappingComposable(
new EdmFunction(
"f", "model", DataSpace.CSpace,
new EdmFunctionPayload()
{
IsComposable = true,
ReturnParameters =
new[]
{
new FunctionParameter(
"ReturnType",
typeUsage,
ParameterMode.ReturnValue),
}
}),
new EdmFunction(
"f", "store", DataSpace.SSpace,
new EdmFunctionPayload()
{
IsComposable = true,
ReturnParameters =
new[]
{
new FunctionParameter(
"ReturnType",
typeUsage,
ParameterMode.ReturnValue),
}
}),
null);
Assert.Empty(entityContainerMapping.FunctionImportMappings);
entityContainerMapping.AddFunctionImportMapping(composableFunctionMapping);
Assert.Same(composableFunctionMapping, entityContainerMapping.FunctionImportMappings.Single());
}
/// <summary>
/// Initializes a new FunctionImportMappingNonComposable instance.
/// </summary>
/// <param name="functionImport">The model function import.</param>
/// <param name="targetFunction">The store non-composable function.</param>
/// <param name="resultMappings">The function import result mappings.</param>
/// <param name="containerMapping">The parent container mapping.</param>
public FunctionImportMappingNonComposable(
EdmFunction functionImport,
EdmFunction targetFunction,
IEnumerable <FunctionImportResultMapping> resultMappings,
EntityContainerMapping containerMapping)
: base(
Check.NotNull(functionImport, "functionImport"),
Check.NotNull(targetFunction, "targetFunction"))
{
Check.NotNull(resultMappings, "resultMappings");
Check.NotNull(containerMapping, "containerMapping");
Debug.Assert(!functionImport.IsComposableAttribute);
Debug.Assert(!targetFunction.IsComposableAttribute);
if (!resultMappings.Any())
{
_internalResultMappings = new ReadOnlyCollection <FunctionImportStructuralTypeMappingKB>(
new[]
{
new FunctionImportStructuralTypeMappingKB(
new List <FunctionImportStructuralTypeMapping>(),
containerMapping.StorageMappingItemCollection.EdmItemCollection)
});
noExplicitResultMappings = true;
}
else
{
Debug.Assert(functionImport.ReturnParameters.Count == resultMappings.Count());
_internalResultMappings = new ReadOnlyCollection <FunctionImportStructuralTypeMappingKB>(
resultMappings
.Select(
resultMapping => new FunctionImportStructuralTypeMappingKB(
resultMapping.TypeMappings,
containerMapping.StorageMappingItemCollection.EdmItemCollection))
.ToArray());
noExplicitResultMappings = false;
}
_resultMappings = new ReadOnlyCollection <FunctionImportResultMapping>(resultMappings.ToList());
}
protected override void Visit(EntityContainerMapping entityContainerMapping)
{
DebugCheck.NotNull(entityContainerMapping);
// at the entry point of visitor, we setup the versions
Debug.Assert(
m_MappingVersion == entityContainerMapping.StorageMappingItemCollection.MappingVersion,
"the original version and the mapping collection version are not the same");
m_MappingVersion = entityContainerMapping.StorageMappingItemCollection.MappingVersion;
m_EdmItemCollection = entityContainerMapping.StorageMappingItemCollection.EdmItemCollection;
int index;
if (!AddObjectToSeenListAndHashBuilder(entityContainerMapping, out index))
{
// if this has been add to the seen list, then just
return;
}
if (m_itemsAlreadySeen.Count > 1)
{
// this means user try another visit over SECM, this is allowed but all the previous visit all lost due to clean
// user can visit different SECM objects by using the same visitor to load the SECM object
Clean();
Visit(entityContainerMapping);
return;
}
AddObjectStartDumpToHashBuilder(entityContainerMapping, index);
#region Inner data visit
AddObjectContentToHashBuilder(entityContainerMapping.Identity);
AddV2ObjectContentToHashBuilder(entityContainerMapping.GenerateUpdateViews, m_MappingVersion);
base.Visit(entityContainerMapping);
#endregion
AddObjectEndDumpToHashBuilder();
}
public void SetReadOnly_is_called_on_child_mapping_items()
{
var conceptualContainer = new EntityContainer("C", DataSpace.CSpace);
var storeContainer = new EntityContainer("S", DataSpace.CSpace);
var containerMapping = new EntityContainerMapping(conceptualContainer, storeContainer, null, false);
var entitySet
= new EntitySet(
"ES", "S", "T", "Q",
new EntityType("ET", "N", DataSpace.SSpace));
var entitySetMapping = new EntitySetMapping(entitySet, containerMapping);
var associationSetMapping
= new AssociationSetMapping(
new AssociationSet(
"AS",
new AssociationType("AT", "N", false, DataSpace.CSpace)),
entitySet);
var functionImportMapping
= new FunctionImportMappingFake(
new EdmFunction("FI", "N", DataSpace.CSpace),
new EdmFunction("TF", "N", DataSpace.SSpace));
containerMapping.AddSetMapping(entitySetMapping);
containerMapping.AddSetMapping(associationSetMapping);
containerMapping.AddFunctionImportMapping(functionImportMapping);
Assert.False(containerMapping.IsReadOnly);
Assert.False(entitySetMapping.IsReadOnly);
Assert.False(associationSetMapping.IsReadOnly);
Assert.False(functionImportMapping.IsReadOnly);
containerMapping.SetReadOnly();
Assert.True(containerMapping.IsReadOnly);
Assert.True(entitySetMapping.IsReadOnly);
Assert.True(associationSetMapping.IsReadOnly);
Assert.True(functionImportMapping.IsReadOnly);
}
protected override void Visit(EntityContainerMapping entityContainerMapping)
{
this.m_MappingVersion = entityContainerMapping.StorageMappingItemCollection.MappingVersion;
this.m_EdmItemCollection = entityContainerMapping.StorageMappingItemCollection.EdmItemCollection;
int instanceIndex;
if (!this.AddObjectToSeenListAndHashBuilder((object)entityContainerMapping, out instanceIndex))
{
return;
}
if (this.m_itemsAlreadySeen.Count > 1)
{
this.Clean();
this.Visit(entityContainerMapping);
}
else
{
this.AddObjectStartDumpToHashBuilder((object)entityContainerMapping, instanceIndex);
this.AddObjectContentToHashBuilder((object)entityContainerMapping.Identity);
this.AddV2ObjectContentToHashBuilder((object)entityContainerMapping.GenerateUpdateViews, this.m_MappingVersion);
base.Visit(entityContainerMapping);
this.AddObjectEndDumpToHashBuilder();
}
}
/// <summary>
/// Initializes a new FunctionImportMappingNonComposable instance.
/// </summary>
/// <param name="functionImport">The model function import.</param>
/// <param name="targetFunction">The store non-composable function.</param>
/// <param name="resultMappings">The function import result mappings.</param>
/// <param name="containerMapping">The parent container mapping.</param>
public FunctionImportMappingNonComposable(
EdmFunction functionImport,
EdmFunction targetFunction,
IEnumerable <FunctionImportResultMapping> resultMappings,
EntityContainerMapping containerMapping)
: base(Check.NotNull <EdmFunction>(functionImport, nameof(functionImport)), Check.NotNull <EdmFunction>(targetFunction, nameof(targetFunction)))
{
Check.NotNull <IEnumerable <FunctionImportResultMapping> >(resultMappings, nameof(resultMappings));
Check.NotNull <EntityContainerMapping>(containerMapping, nameof(containerMapping));
if (!resultMappings.Any <FunctionImportResultMapping>())
{
this._internalResultMappings = new ReadOnlyCollection <FunctionImportStructuralTypeMappingKB>((IList <FunctionImportStructuralTypeMappingKB>) new FunctionImportStructuralTypeMappingKB[1]
{
new FunctionImportStructuralTypeMappingKB((IEnumerable <FunctionImportStructuralTypeMapping>) new List <FunctionImportStructuralTypeMapping>(), (ItemCollection)(containerMapping.StorageMappingItemCollection != null ? containerMapping.StorageMappingItemCollection.EdmItemCollection : new EdmItemCollection(new EdmModel(DataSpace.CSpace, 3.0))))
});
this.noExplicitResultMappings = true;
}
else
{
this._internalResultMappings = new ReadOnlyCollection <FunctionImportStructuralTypeMappingKB>((IList <FunctionImportStructuralTypeMappingKB>)resultMappings.Select <FunctionImportResultMapping, FunctionImportStructuralTypeMappingKB>((Func <FunctionImportResultMapping, FunctionImportStructuralTypeMappingKB>)(resultMapping => new FunctionImportStructuralTypeMappingKB((IEnumerable <FunctionImportStructuralTypeMapping>)resultMapping.TypeMappings, (ItemCollection)containerMapping.StorageMappingItemCollection.EdmItemCollection))).ToArray <FunctionImportStructuralTypeMappingKB>());
this.noExplicitResultMappings = false;
}
this._resultMappings = new ReadOnlyCollection <FunctionImportResultMapping>((IList <FunctionImportResultMapping>)resultMappings.ToList <FunctionImportResultMapping>());
}
internal EntitySetBaseMapping(EntityContainerMapping containerMapping)
{
this._containerMapping = containerMapping;
}
/// <summary>
/// Initializes a new FunctionImportMappingComposable instance.
/// </summary>
/// <param name="functionImport">The model function import.</param>
/// <param name="targetFunction">The store composable function.</param>
/// <param name="resultMapping">The result mapping for the function import.</param>
/// <param name="containerMapping">The parent container mapping.</param>
public FunctionImportMappingComposable(
EdmFunction functionImport,
EdmFunction targetFunction,
FunctionImportResultMapping resultMapping,
EntityContainerMapping containerMapping)
: base(
Check.NotNull(functionImport, "functionImport"),
Check.NotNull(targetFunction, "targetFunction"))
{
Check.NotNull(resultMapping, "resultMapping");
Check.NotNull(containerMapping, "containerMapping");
if (!functionImport.IsComposableAttribute)
{
throw new ArgumentException(Strings.NonComposableFunctionCannotBeMappedAsComposable("functionImport"));
}
if (!targetFunction.IsComposableAttribute)
{
throw new ArgumentException(Strings.NonComposableFunctionCannotBeMappedAsComposable("targetFunction"));
}
EdmType resultType;
if (!MetadataHelper.TryGetFunctionImportReturnType(functionImport, 0, out resultType))
{
throw new ArgumentException(Strings.InvalidReturnTypeForComposableFunction);
}
// when this method is invoked when a CodeFirst model is being built (e.g. from a custom convention) the
// StorageMappingItemCollection will be null. In this case we can call the converting method directly which
// will return the correct result but the result won't be memoized. This however does not matter at this
// point since the model is still being constructed.
var cTypeTargetFunction =
containerMapping.StorageMappingItemCollection != null
? containerMapping.StorageMappingItemCollection.StoreItemCollection.ConvertToCTypeFunction(targetFunction)
: StoreItemCollection.ConvertFunctionSignatureToCType(targetFunction);
var cTypeTvfElementType = TypeHelpers.GetTvfReturnType(cTypeTargetFunction);
var sTypeTvfElementType = TypeHelpers.GetTvfReturnType(targetFunction);
if (cTypeTvfElementType == null)
{
Debug.Assert(sTypeTvfElementType == null);
throw new ArgumentException(
Strings.Mapping_FunctionImport_ResultMapping_InvalidSType(functionImport.Identity),
"functionImport");
}
var errors = new List <EdmSchemaError>();
var functionImportHelper = new FunctionImportMappingComposableHelper(
containerMapping,
String.Empty,
errors);
FunctionImportMappingComposable mapping;
if (Helper.IsStructuralType(resultType))
{
functionImportHelper.TryCreateFunctionImportMappingComposableWithStructuralResult(
functionImport,
cTypeTargetFunction,
resultMapping.SourceList,
cTypeTvfElementType,
sTypeTvfElementType,
LineInfo.Empty,
out mapping);
}
else
{
Debug.Assert(TypeSemantics.IsScalarType(resultType));
Debug.Assert(resultMapping.TypeMappings.Count == 0);
functionImportHelper.TryCreateFunctionImportMappingComposableWithScalarResult(
functionImport,
cTypeTargetFunction,
targetFunction,
resultType,
cTypeTvfElementType,
LineInfo.Empty,
out mapping);
}
if (mapping == null)
{
throw new InvalidOperationException(errors.Count > 0 ? errors[0].Message : String.Empty);
}
_containerMapping = mapping._containerMapping;
m_commandParameters = mapping.m_commandParameters;
m_structuralTypeMappings = mapping.m_structuralTypeMappings;
m_targetFunctionKeys = mapping.m_targetFunctionKeys;
_resultMapping = resultMapping;
}
internal InputForComputingCellGroups(EntityContainerMapping containerMapping, ConfigViewGenerator config)
{
ContainerMapping = containerMapping;
Config = config;
}
internal AssociationSetMapping(AssociationSet associationSet, EntityContainerMapping containerMapping)
: base(containerMapping)
{
_associationSet = associationSet;
}
/// <summary>
/// Initializes a new AssociationSetMapping instance.
/// </summary>
/// <param name="associationSet">The association set to be mapped.</param>
/// <param name="storeEntitySet">The store entity set to be mapped.</param>
/// <param name="containerMapping">The parent container mapping.</param>
public AssociationSetMapping(AssociationSet associationSet, EntitySet storeEntitySet, EntityContainerMapping containerMapping)
: base(containerMapping)
{
Check.NotNull(associationSet, "associationSet");
Check.NotNull(storeEntitySet, "storeEntitySet");
_associationSet = associationSet;
_associationTypeMapping = new AssociationTypeMapping(associationSet.ElementType, this);
_associationTypeMapping.MappingFragment
= new MappingFragment(storeEntitySet, _associationTypeMapping, false);
}
/// <summary>
/// Initializes a new FunctionImportMappingComposable instance.
/// </summary>
/// <param name="functionImport">The model function import.</param>
/// <param name="targetFunction">The store composable function.</param>
/// <param name="resultMapping">The result mapping for the function import.</param>
/// <param name="containerMapping">The parent container mapping.</param>
public FunctionImportMappingComposable(
EdmFunction functionImport,
EdmFunction targetFunction,
FunctionImportResultMapping resultMapping,
EntityContainerMapping containerMapping)
: base(
Check.NotNull(functionImport, "functionImport"),
Check.NotNull(targetFunction, "targetFunction"))
{
Check.NotNull(resultMapping, "resultMapping");
Check.NotNull(containerMapping, "containerMapping");
if (!functionImport.IsComposableAttribute)
{
throw new ArgumentException(Strings.NonComposableFunctionCannotBeMappedAsComposable("functionImport"));
}
if (!targetFunction.IsComposableAttribute)
{
throw new ArgumentException(Strings.NonComposableFunctionCannotBeMappedAsComposable("targetFunction"));
}
if (functionImport.EntitySet != null)
{
throw new NotSupportedException(Strings.ComposableFunctionImportsReturningEntitiesNotSupported);
}
EdmType resultType;
if (!MetadataHelper.TryGetFunctionImportReturnType(functionImport, 0, out resultType))
{
throw new ArgumentException(Strings.InvalidReturnTypeForComposableFunction);
}
// Function mapping is allowed only for TVFs on the s-space.
var cTypeTargetFunction = containerMapping.StorageMappingItemCollection.StoreItemCollection.ConvertToCTypeFunction(targetFunction);
var cTypeTvfElementType = TypeHelpers.GetTvfReturnType(cTypeTargetFunction);
var sTypeTvfElementType = TypeHelpers.GetTvfReturnType(targetFunction);
if (cTypeTvfElementType == null)
{
Debug.Assert(sTypeTvfElementType == null);
throw new ArgumentException(
Strings.Mapping_FunctionImport_ResultMapping_InvalidSType(functionImport.Identity),
"functionImport");
}
var errors = new List <EdmSchemaError>();
var functionImportHelper = new FunctionImportMappingComposableHelper(
containerMapping,
String.Empty,
errors);
FunctionImportMappingComposable mapping;
if (Helper.IsStructuralType(resultType))
{
functionImportHelper.TryCreateFunctionImportMappingComposableWithStructuralResult(
functionImport,
cTypeTargetFunction,
resultMapping.SourceList,
cTypeTvfElementType,
sTypeTvfElementType,
LineInfo.Empty,
out mapping);
}
else
{
Debug.Assert(TypeSemantics.IsScalarType(resultType));
Debug.Assert(resultMapping.TypeMappings.Count == 0);
functionImportHelper.TryCreateFunctionImportMappingComposableWithScalarResult(
functionImport,
cTypeTargetFunction,
targetFunction,
resultType,
cTypeTvfElementType,
LineInfo.Empty,
out mapping);
}
if (mapping == null)
{
throw new InvalidOperationException(errors.Count > 0 ? errors[0].Message : String.Empty);
}
_containerMapping = mapping._containerMapping;
m_commandParameters = mapping.m_commandParameters;
m_structuralTypeMappings = mapping.m_structuralTypeMappings;
m_targetFunctionKeys = mapping.m_targetFunctionKeys;
_resultMapping = resultMapping;
}