// <summary> // Search for a Mapping metadata with the specified type key. // </summary> internal virtual MappingBase GetMap(GlobalItem item) { DebugCheck.NotNull(item); //will only be implemented by Mapping Item Collections throw Error.NotSupported(); }
/// <summary> /// Search for a Mapping metadata with the specified type key. /// </summary> /// <param name="item"></param> internal virtual Map GetMap(GlobalItem item) { Contract.Requires(item != null); //will only be implemented by Mapping Item Collections throw Error.NotSupported(); }
private void ValidateSpace(GlobalItem item, string parameterName) { if (item.DataSpace != _dataSpace) { throw new ArgumentException(Strings.EdmModel_AddItem_NonMatchingNamespace, parameterName); } }
private bool ContainsMap(GlobalItem cspaceItem, out ObjectTypeMapping map) { Debug.Assert(cspaceItem.DataSpace == DataSpace.CSpace, "ContainsMap: It must be a CSpace item"); int index; if (cdmTypeIndexes.TryGetValue(cspaceItem.Identity, out index)) { map = (ObjectTypeMapping)this[index]; return true; } map = null; return false; }
/// <summary> /// Search for a Mapping metadata with the specified type key. /// </summary> /// <param name="item"></param> /// <param name="map"></param> /// <returns>Returns false if no match found.</returns> internal override bool TryGetMap(GlobalItem item, out Map map) { if (item == null) { map = null; return false; } var typeSpace = item.DataSpace; //For transient types just create a map on fly and return var edmType = item as EdmType; if (edmType != null) { if (Helper.IsTransientType(edmType)) { map = GetOCMapForTransientType(edmType, typeSpace); if (map != null) { return true; } else { return false; } } } return TryGetMap(item.Identity, typeSpace, out map); }
/// <summary> /// Search for a Mapping metadata with the specified type key. /// </summary> /// <param name="item"></param> internal override Map GetMap(GlobalItem item) { Map map; if (!TryGetMap(item, out map)) { throw new InvalidOperationException(Strings.Mapping_Object_InvalidType(item.Identity)); } return map; }
internal static bool IsEdmFunction(GlobalItem item) { return(BuiltInTypeKind.EdmFunction == item.BuiltInTypeKind); }
internal static bool IsEntityContainer(GlobalItem item) { return(BuiltInTypeKind.EntityContainer == item.BuiltInTypeKind); }
internal static bool IsRowType(GlobalItem item) { return(BuiltInTypeKind.RowType == item.BuiltInTypeKind); }
internal static bool IsCollectionType(GlobalItem item) { return(BuiltInTypeKind.CollectionType == item.BuiltInTypeKind); }
// <summary> // Search for a Mapping metadata with the specified type key. // </summary> // <returns> Returns false if no match found. </returns> internal override bool TryGetMap(GlobalItem item, out MappingBase map) { if (item == null) { map = null; return false; } var typeSpace = item.DataSpace; if (typeSpace != DataSpace.CSpace) { map = null; return false; } return TryGetMap(item.Identity, typeSpace, out map); }
// <summary> // Search for a Mapping metadata with the specified type key. // </summary> internal override MappingBase GetMap(GlobalItem item) { var typeSpace = item.DataSpace; if (typeSpace != DataSpace.CSpace) { throw new InvalidOperationException(Strings.Mapping_Storage_InvalidSpace(typeSpace)); } return GetMap(item.Identity, typeSpace); }
// <summary> // Search for a Mapping metadata with the specified type key. // </summary> // <returns> Returns false if no match found. </returns> internal virtual bool TryGetMap(GlobalItem item, out MappingBase map) { //will only be implemented by Mapping Item Collections throw Error.NotSupported(); }
private static EdmFunction ConvertToFunction( System.Data.Entity.Core.SchemaObjectModel.Function somFunction, DbProviderManifest providerManifest, Converter.ConversionCache convertedItemCache, EntityContainer functionImportEntityContainer, Dictionary <SchemaElement, GlobalItem> newGlobalItems) { GlobalItem globalItem = (GlobalItem)null; if (!somFunction.IsFunctionImport && newGlobalItems.TryGetValue((SchemaElement)somFunction, out globalItem)) { return((EdmFunction)globalItem); } bool areConvertingForProviderManifest = somFunction.Schema.DataModel == SchemaDataModelOption.ProviderManifestModel; List <FunctionParameter> functionParameterList1 = new List <FunctionParameter>(); if (somFunction.ReturnTypeList != null) { int num = 0; foreach (ReturnType returnType in (IEnumerable <ReturnType>)somFunction.ReturnTypeList) { TypeUsage functionTypeUsage = Converter.GetFunctionTypeUsage(somFunction is ModelFunction, somFunction, (FacetEnabledSchemaElement)returnType, providerManifest, areConvertingForProviderManifest, returnType.Type, returnType.CollectionKind, returnType.IsRefType, convertedItemCache, newGlobalItems); if (functionTypeUsage == null) { return((EdmFunction)null); } string str = num == 0 ? string.Empty : num.ToString((IFormatProvider)CultureInfo.InvariantCulture); ++num; FunctionParameter functionParameter = new FunctionParameter("ReturnType" + str, functionTypeUsage, ParameterMode.ReturnValue); Converter.AddOtherContent((SchemaElement)returnType, (MetadataItem)functionParameter); functionParameterList1.Add(functionParameter); } } else if (somFunction.Type != null) { TypeUsage functionTypeUsage = Converter.GetFunctionTypeUsage(somFunction is ModelFunction, somFunction, (FacetEnabledSchemaElement)null, providerManifest, areConvertingForProviderManifest, somFunction.Type, somFunction.CollectionKind, somFunction.IsReturnAttributeReftype, convertedItemCache, newGlobalItems); if (functionTypeUsage == null) { return((EdmFunction)null); } functionParameterList1.Add(new FunctionParameter("ReturnType", functionTypeUsage, ParameterMode.ReturnValue)); } EntitySet[] entitySetArray = (EntitySet[])null; string name; if (somFunction.IsFunctionImport) { FunctionImportElement functionImportElement = (FunctionImportElement)somFunction; name = functionImportElement.Container.Name; if (functionImportElement.EntitySet != null) { EntityContainer container = functionImportEntityContainer; entitySetArray = new EntitySet[1] { Converter.GetEntitySet(functionImportElement.EntitySet, container) }; } else if (functionImportElement.ReturnTypeList != null) { EntityContainer entityContainer = functionImportEntityContainer; entitySetArray = functionImportElement.ReturnTypeList.Select <ReturnType, EntitySet>((Func <ReturnType, EntitySet>)(returnType => { if (returnType.EntitySet == null) { return((EntitySet)null); } return(Converter.GetEntitySet(returnType.EntitySet, functionImportEntityContainer)); })).ToArray <EntitySet>(); } } else { name = somFunction.Namespace; } List <FunctionParameter> functionParameterList2 = new List <FunctionParameter>(); foreach (Parameter parameter in somFunction.Parameters) { TypeUsage functionTypeUsage = Converter.GetFunctionTypeUsage(somFunction is ModelFunction, somFunction, (FacetEnabledSchemaElement)parameter, providerManifest, areConvertingForProviderManifest, parameter.Type, parameter.CollectionKind, parameter.IsRefType, convertedItemCache, newGlobalItems); if (functionTypeUsage == null) { return((EdmFunction)null); } FunctionParameter functionParameter = new FunctionParameter(parameter.Name, functionTypeUsage, Converter.GetParameterMode(parameter.ParameterDirection)); Converter.AddOtherContent((SchemaElement)parameter, (MetadataItem)functionParameter); if (parameter.Documentation != null) { functionParameter.Documentation = Converter.ConvertToDocumentation(parameter.Documentation); } functionParameterList2.Add(functionParameter); } EdmFunction edmFunction = new EdmFunction(somFunction.Name, name, Converter.GetDataSpace(providerManifest), new EdmFunctionPayload() { Schema = somFunction.DbSchema, StoreFunctionName = somFunction.StoreFunctionName, CommandText = somFunction.CommandText, EntitySets = (IList <EntitySet>)entitySetArray, IsAggregate = new bool?(somFunction.IsAggregate), IsBuiltIn = new bool?(somFunction.IsBuiltIn), IsNiladic = new bool?(somFunction.IsNiladicFunction), IsComposable = new bool?(somFunction.IsComposable), IsFromProviderManifest = new bool?(areConvertingForProviderManifest), IsFunctionImport = new bool?(somFunction.IsFunctionImport), ReturnParameters = (IList <FunctionParameter>)functionParameterList1.ToArray(), Parameters = (IList <FunctionParameter>)functionParameterList2.ToArray(), ParameterTypeSemantics = new ParameterTypeSemantics?(somFunction.ParameterTypeSemantics) }); if (!somFunction.IsFunctionImport) { newGlobalItems.Add((SchemaElement)somFunction, (GlobalItem)edmFunction); } if (somFunction.Documentation != null) { edmFunction.Documentation = Converter.ConvertToDocumentation(somFunction.Documentation); } Converter.AddOtherContent((SchemaElement)somFunction, (MetadataItem)edmFunction); return(edmFunction); }