internal StorageModificationFunctionMapping(
EntitySetBase entitySet,
EntityTypeBase entityType,
EdmFunction function,
IEnumerable<StorageModificationFunctionParameterBinding> parameterBindings,
FunctionParameter rowsAffectedParameter,
IEnumerable<StorageModificationFunctionResultBinding> resultBindings)
{
//Contract.Requires(entitySet != null);
//Contract.Requires(function != null);
//Contract.Requires(parameterBindings != null);
Function = function;
RowsAffectedParameter = rowsAffectedParameter;
ParameterBindings = parameterBindings.ToList().AsReadOnly();
if (null != resultBindings)
{
var bindings = resultBindings.ToList();
if (0 < bindings.Count)
{
ResultBindings = bindings.AsReadOnly();
}
}
CollocatedAssociationSetEnds =
GetReferencedAssociationSetEnds(entitySet as EntitySet, entityType as EntityType, parameterBindings)
.ToList()
.AsReadOnly();
}
internal StorageModificationFunctionParameterBinding(
FunctionParameter parameter, StorageModificationFunctionMemberPath memberPath, bool isCurrent)
{
//Contract.Requires(parameter != null);
//Contract.Requires(memberPath != null);
Parameter = parameter;
MemberPath = memberPath;
IsCurrent = isCurrent;
}
private void AddFunction(PrimitiveTypeKind returnType, string functionName, KeyValuePair <string, PrimitiveTypeKind>[] parameterDefinitions)
{
FunctionParameter returnParameter = CreateReturnParameter(returnType);
FunctionParameter[] parameters = parameterDefinitions.Select(paramDef => CreateParameter(paramDef.Value, paramDef.Key)).ToArray();
EdmFunction function = new EdmFunction(functionName,
EdmConstants.EdmNamespace,
DataSpace.CSpace,
new EdmFunctionPayload
{
IsBuiltIn = true,
ReturnParameters = new FunctionParameter[] { returnParameter },
Parameters = parameters,
IsFromProviderManifest = true,
});
function.SetReadOnly();
this.functions.Add(function);
}
/// <summary>
/// Converts a function from SOM to metadata
/// </summary>
/// <param name="somFunction">The SOM element to process</param>
/// <param name="providerManifest">The provider manifest to be used for conversion</param>
/// <param name="convertedItemCache">The item collection for currently existing metadata objects</param>
/// <param name="functionImportEntityContainer">For function imports, the entity container including the function declaration</param>
/// <param name="newGlobalItems">The new GlobalItem objects that are created as a result of this conversion</param>
/// <returns>The function object resulting from the convert</returns>
private static EdmFunction ConvertToFunction(Som.Function somFunction,
DbProviderManifest providerManifest,
ConversionCache convertedItemCache,
EntityContainer functionImportEntityContainer,
Dictionary<Som.SchemaElement, GlobalItem> newGlobalItems)
{
// If we already have it, don't bother converting
GlobalItem globalItem = null;
// if we are converted the function import, we need not check the global items collection,
// since the function imports are local to the entity container
if (!somFunction.IsFunctionImport && newGlobalItems.TryGetValue(somFunction, out globalItem))
{
return (EdmFunction)globalItem;
}
bool areConvertingForProviderManifest = somFunction.Schema.DataModel == Som.SchemaDataModelOption.ProviderManifestModel;
List<FunctionParameter> returnParameters = new List<FunctionParameter>();
if (somFunction.ReturnTypeList != null)
{
int i = 0;
foreach (Som.ReturnType somReturnType in somFunction.ReturnTypeList)
{
TypeUsage returnType = GetFunctionTypeUsage(somFunction is Som.ModelFunction,
somFunction,
somReturnType,
providerManifest,
areConvertingForProviderManifest,
somReturnType.Type,
somReturnType.CollectionKind,
somReturnType.IsRefType /*isRefType*/,
somFunction,
convertedItemCache,
newGlobalItems);
if (null != returnType)
{
// Create the return parameter object, need to set the declaring type explicitly on the return parameter
// because we aren't adding it to the members collection
string modifier = i == 0 ? string.Empty : i.ToString(System.Globalization.CultureInfo.InvariantCulture);
i++;
FunctionParameter returnParameter = new FunctionParameter(EdmConstants.ReturnType + modifier, returnType, ParameterMode.ReturnValue);
AddOtherContent(somReturnType, returnParameter);
returnParameters.Add(returnParameter);
}
else
{
return null;
}
}
}
// this case must be second to avoid calling somFunction.Type when returnTypeList has more than one element.
else if (somFunction.Type != null)
{
TypeUsage returnType = GetFunctionTypeUsage(somFunction is Som.ModelFunction,
somFunction,
null,
providerManifest,
areConvertingForProviderManifest,
somFunction.Type,
somFunction.CollectionKind,
somFunction.IsReturnAttributeReftype /*isRefType*/,
somFunction,
convertedItemCache,
newGlobalItems);
if (null != returnType)
{
// Create the return parameter object, need to set the declaring type explicitly on the return parameter
// because we aren't adding it to the members collection
returnParameters.Add(new FunctionParameter(EdmConstants.ReturnType, returnType, ParameterMode.ReturnValue));
}
else
{
//Return type was specified but we could not find a type usage
return null;
}
}
string functionNamespace;
EntitySet[] entitySets = null;
if (somFunction.IsFunctionImport)
{
var somFunctionImport = (Som.FunctionImportElement)somFunction;
functionNamespace = somFunctionImport.Container.Name;
if (null != somFunctionImport.EntitySet)
{
EntityContainer entityContainer;
Debug.Assert(somFunctionImport.ReturnTypeList == null || somFunctionImport.ReturnTypeList.Count == 1,
"EntitySet cannot be specified on a FunctionImport if there are multiple ReturnType children");
Debug.Assert(functionImportEntityContainer != null, "functionImportEntityContainer must be specified during function import conversion");
entityContainer = functionImportEntityContainer;
entitySets = new EntitySet[] { GetEntitySet(somFunctionImport.EntitySet, entityContainer) };
}
else if (null != somFunctionImport.ReturnTypeList)
{
Debug.Assert(functionImportEntityContainer != null, "functionImportEntityContainer must be specified during function import conversion");
EntityContainer entityContainer = functionImportEntityContainer;
entitySets = somFunctionImport.ReturnTypeList
.Select(returnType => null != returnType.EntitySet
? GetEntitySet(returnType.EntitySet, functionImportEntityContainer)
: null)
.ToArray();
}
}
else
{
functionNamespace = somFunction.Namespace;
}
List<FunctionParameter> parameters = new List<FunctionParameter>();
foreach (Som.Parameter somParameter in somFunction.Parameters)
{
TypeUsage parameterType = GetFunctionTypeUsage(somFunction is Som.ModelFunction,
somFunction,
somParameter,
providerManifest,
areConvertingForProviderManifest,
somParameter.Type,
somParameter.CollectionKind,
somParameter.IsRefType,
somParameter,
convertedItemCache,
newGlobalItems);
if (parameterType == null)
{
return null;
}
FunctionParameter parameter = new FunctionParameter(somParameter.Name,
parameterType,
GetParameterMode(somParameter.ParameterDirection));
AddOtherContent(somParameter, parameter);
if (somParameter.Documentation != null)
{
parameter.Documentation = ConvertToDocumentation(somParameter.Documentation);
}
parameters.Add(parameter);
}
EdmFunction function = new EdmFunction(somFunction.Name,
functionNamespace,
GetDataSpace(providerManifest),
new EdmFunctionPayload
{
Schema = somFunction.DbSchema,
StoreFunctionName = somFunction.StoreFunctionName,
CommandText = somFunction.CommandText,
EntitySets = entitySets,
IsAggregate = somFunction.IsAggregate,
IsBuiltIn = somFunction.IsBuiltIn,
IsNiladic = somFunction.IsNiladicFunction,
IsComposable = somFunction.IsComposable,
IsFromProviderManifest = areConvertingForProviderManifest,
IsFunctionImport = somFunction.IsFunctionImport,
ReturnParameters = returnParameters.ToArray(),
Parameters = parameters.ToArray(),
ParameterTypeSemantics = somFunction.ParameterTypeSemantics,
});
// Add this function to new global items, only if it is not a function import
if (!somFunction.IsFunctionImport)
{
newGlobalItems.Add(somFunction, function);
}
//Check if we already converted functions since we are loading it from
//ssdl we could see functions many times.
GlobalItem returnFunction = null;
Debug.Assert(!convertedItemCache.ItemCollection.TryGetValue(function.Identity, false, out returnFunction),
"Function duplicates must be checked by som");
// Extract the optional Documentation
if (somFunction.Documentation != null)
{
function.Documentation = ConvertToDocumentation(somFunction.Documentation);
}
AddOtherContent(somFunction, function);
return function;
}
/// <summary>
/// Convert the S type function parameters and returnType to C types.
/// </summary>
private EdmFunction ConvertFunctionSignatureToCType(EdmFunction sTypeFunction)
{
Debug.Assert(sTypeFunction.DataSpace == Edm.DataSpace.SSpace, "sTypeFunction.DataSpace == Edm.DataSpace.SSpace");
if (sTypeFunction.IsFromProviderManifest)
{
return(sTypeFunction);
}
FunctionParameter returnParameter = null;
if (sTypeFunction.ReturnParameter != null)
{
TypeUsage edmTypeUsageReturnParameter =
MetadataHelper.ConvertStoreTypeUsageToEdmTypeUsage(sTypeFunction.ReturnParameter.TypeUsage);
returnParameter =
new FunctionParameter(
sTypeFunction.ReturnParameter.Name,
edmTypeUsageReturnParameter,
sTypeFunction.ReturnParameter.GetParameterMode());
}
List <FunctionParameter> parameters = new List <FunctionParameter>();
if (sTypeFunction.Parameters.Count > 0)
{
foreach (var parameter in sTypeFunction.Parameters)
{
TypeUsage edmTypeUsage = MetadataHelper.ConvertStoreTypeUsageToEdmTypeUsage(parameter.TypeUsage);
FunctionParameter edmTypeParameter = new FunctionParameter(parameter.Name, edmTypeUsage, parameter.GetParameterMode());
parameters.Add(edmTypeParameter);
}
}
FunctionParameter[] returnParameters =
returnParameter == null ? new FunctionParameter[0] : new FunctionParameter[] { returnParameter };
EdmFunction edmFunction = new EdmFunction(sTypeFunction.Name,
sTypeFunction.NamespaceName,
DataSpace.CSpace,
new EdmFunctionPayload
{
Schema = sTypeFunction.Schema,
StoreFunctionName = sTypeFunction.StoreFunctionNameAttribute,
CommandText = sTypeFunction.CommandTextAttribute,
IsAggregate = sTypeFunction.AggregateAttribute,
IsBuiltIn = sTypeFunction.BuiltInAttribute,
IsNiladic = sTypeFunction.NiladicFunctionAttribute,
IsComposable = sTypeFunction.IsComposableAttribute,
IsFromProviderManifest = sTypeFunction.IsFromProviderManifest,
IsCachedStoreFunction = true,
IsFunctionImport = sTypeFunction.IsFunctionImport,
ReturnParameters = returnParameters,
Parameters = parameters.ToArray(),
ParameterTypeSemantics = sTypeFunction.ParameterTypeSemanticsAttribute,
});
edmFunction.SetReadOnly();
return(edmFunction);
}
protected override void Visit(FunctionParameter functionParameter)
{
int index;
if (!this.AddObjectToSeenListAndHashBuilder(functionParameter, out index))
{
return;
}
this.AddObjectStartDumpToHashBuilder(functionParameter, index);
#region Inner data visit
this.AddObjectContentToHashBuilder(functionParameter.Identity);
// Identity already has Name
this.AddObjectContentToHashBuilder(functionParameter.Mode);
base.Visit(functionParameter);
#endregion
this.AddObjectEndDumpToHashBuilder();
}
private string FunctionImportTypeName(FunctionParameter parameter)
{
return parameter.Mode == ParameterMode.In ? parameter.TypeUsage.EdmType.Name : "ObjectParameter";
}
private void CreateEdmFunction(LoadMethodSessionState session, DbObjectKey functionKey, List<FunctionDetailsReader.Memento> parameters)
{
Debug.Assert(parameters.Count != 0, "don't call the method with no data");
FunctionDetailsReader row = parameters[0].CreateReader();
FunctionParameter returnParameter = null;
bool isValid = true;
List<EdmSchemaError> errors = new List<EdmSchemaError>();
if (row.ReturnType != null)
{
Debug.Assert(!row.IsTvf, "TVF can't have ReturnType (used only for scalars).");
bool excludedForTarget;
TypeUsage returnType = GetScalarFunctionTypeUsage(session, row.ReturnType, out excludedForTarget);
if (returnType != null)
{
returnParameter = new FunctionParameter(EdmConstants.ReturnType, returnType, ParameterMode.ReturnValue);
}
else
{
isValid = false;
errors.Add(new EdmSchemaError(excludedForTarget ?
Strings.UnsupportedFunctionReturnDataTypeForTarget(row.ProcedureName, row.ReturnType) :
Strings.UnsupportedFunctionReturnDataType(row.ProcedureName, row.ReturnType),
(int)ModelBuilderErrorCode.UnsupportedType,
EdmSchemaErrorSeverity.Warning));
}
}
else if (row.IsTvf)
{
if (_targetEntityFrameworkVersion < EntityFrameworkVersions.Version3)
{
return;
}
RowType tvfReturnType;
if (session.TryGetTvfReturnType(functionKey, out tvfReturnType) && !session.InvalidTypes.Contains(tvfReturnType))
{
var collectionType = tvfReturnType.GetCollectionType();
collectionType.SetReadOnly();
returnParameter = new FunctionParameter(EdmConstants.ReturnType, TypeUsage.Create(collectionType), ParameterMode.ReturnValue);
}
else
{
isValid = false;
// If the TVF return type exists, but it is not valid, then reassign all its errors directly to the TVF.
// This is needed in order to avoid the following kind of error reporting:
// SSDL:
//
// <!-- Errors found while generating type:
// column1 type not supported
// column2 type not supported
// <RowType />
// -->
// ...
// ...
// <!-- Error found while generating type:
// TableReferencedByTvfWasNotFound
// <Function Name="TVF" .... />
// -->
//
// Instead we want something like this:
//
// <!-- Errors found while generating type:
// column1 type not supported
// column2 type not supported
// TableReferencedByTvfWasNotFound
// <Function Name="TVF" .... />
// -->
//
List<EdmSchemaError> tvfReturnTypeErrors;
if (tvfReturnType != null && session.ItemToErrorsMap.TryGetValue(tvfReturnType, out tvfReturnTypeErrors))
{
errors.AddRange(tvfReturnTypeErrors);
session.ItemToErrorsMap.Remove(tvfReturnType);
if (session.InvalidTypes.Contains(tvfReturnType))
{
session.InvalidTypes.Remove(tvfReturnType);
}
}
errors.Add(new EdmSchemaError(
Strings.TableReferencedByTvfWasNotFound(functionKey),
(int)ModelBuilderErrorCode.MissingTvfReturnTable,
EdmSchemaErrorSeverity.Warning));
}
}
bool caseSensitive = false;
UniqueIdentifierService uniqueIdentifiers = new UniqueIdentifierService(caseSensitive);
List<FunctionParameter> functionParameters = new List<FunctionParameter>();
for (int i = 0; i < parameters.Count && !row.IsParameterNameNull; i++)
{
row.Attach(parameters[i]);
TypeUsage parameterType = null;
bool excludedForTarget = false;
if (!row.IsParameterTypeNull)
{
parameterType = GetScalarFunctionTypeUsage(session, row.ParameterType, out excludedForTarget);
}
if (parameterType != null)
{
ParameterMode mode;
if (!row.TryGetParameterMode(out mode))
{
isValid = false;
string modeValue = "null";
if (!row.IsParameterModeNull)
{
modeValue = row.ProcParameterMode;
}
errors.Add(new EdmSchemaError(
Strings.ParameterDirectionNotValid(
row.ProcedureName,
row.ParameterName,
modeValue),
(int)ModelBuilderErrorCode.ParameterDirectionNotValid,
EdmSchemaErrorSeverity.Warning));
}
// the mode will get defaulted to something, so it is ok to keep creating after
// an error getting the mode value.
string parameterName = EntityModelSchemaGenerator.CreateValidEcmaName(row.ParameterName, 'p');
parameterName = uniqueIdentifiers.AdjustIdentifier(parameterName);
FunctionParameter parameter = new FunctionParameter(parameterName, parameterType, mode);
functionParameters.Add(parameter);
}
else
{
isValid = false;
string typeValue = "null";
if (!row.IsParameterTypeNull)
{
typeValue = row.ParameterType;
}
errors.Add(new EdmSchemaError(excludedForTarget ?
Strings.UnsupportedFunctionParameterDataTypeForTarget(row.ProcedureName, row.ParameterName, i, typeValue) :
Strings.UnsupportedFunctionParameterDataType(row.ProcedureName, row.ParameterName, i, typeValue),
(int)ModelBuilderErrorCode.UnsupportedType,
EdmSchemaErrorSeverity.Warning));
}
}
string functionName = EntityModelSchemaGenerator.CreateValidEcmaName(row.ProcedureName, 'f');
functionName = session.UsedTypeNames.AdjustIdentifier(functionName);
FunctionParameter[] returnParameters =
returnParameter == null ? new FunctionParameter[0] : new FunctionParameter[] {returnParameter};
EdmFunction function = new EdmFunction(functionName,
_namespaceName,
DataSpace.SSpace,
new EdmFunctionPayload
{
Schema = row.Schema,
StoreFunctionName = functionName != row.ProcedureName ? row.ProcedureName : null,
IsAggregate = row.IsIsAggregate,
IsBuiltIn = row.IsBuiltIn,
IsNiladic = row.IsNiladic,
IsComposable = row.IsComposable,
ReturnParameters = returnParameters,
Parameters = functionParameters.ToArray()
});
function.SetReadOnly();
session.AddErrorsForType(function, errors);
if (isValid)
{
session.Functions.Add(function);
}
else
{
session.InvalidTypes.Add(function);
}
}
protected virtual void Visit(FunctionParameter functionParameter)
{
Visit(functionParameter.DeclaringFunction);
Visit(functionParameter.TypeUsage);
}
internal StorageModificationFunctionParameterBinding(FunctionParameter parameter, StorageModificationFunctionMemberPath memberPath, bool isCurrent)
{
this.Parameter = EntityUtil.CheckArgumentNull(parameter, "parameter");
this.MemberPath = EntityUtil.CheckArgumentNull(memberPath, "memberPath");
this.IsCurrent = isCurrent;
}
internal StorageModificationFunctionMapping(
EntitySetBase entitySet,
EntityTypeBase entityType,
EdmFunction function,
IEnumerable<StorageModificationFunctionParameterBinding> parameterBindings,
FunctionParameter rowsAffectedParameter,
IEnumerable<StorageModificationFunctionResultBinding> resultBindings)
{
EntityUtil.CheckArgumentNull(entitySet, "entitySet");
this.Function = EntityUtil.CheckArgumentNull(function, "function");
this.RowsAffectedParameter = rowsAffectedParameter;
this.ParameterBindings = EntityUtil.CheckArgumentNull(parameterBindings, "parameterBindings")
.ToList().AsReadOnly();
if (null != resultBindings)
{
List<StorageModificationFunctionResultBinding> bindings = resultBindings.ToList();
if (0 < bindings.Count)
{
ResultBindings = bindings.AsReadOnly();
}
}
this.CollocatedAssociationSetEnds = GetReferencedAssociationSetEnds(entitySet as EntitySet, entityType as EntityType, parameterBindings)
.ToList()
.AsReadOnly();
}
// requires: parameter type is constrained to be a scalar type
// Determines CLR type for function parameter
private static Type DetermineParameterType(FunctionParameter parameter)
{
Debug.Assert(null != parameter && MetadataUtil.IsPrimitiveType(parameter.TypeUsage.EdmType),
"validation must ensure only scalar type parameter are given");
if (parameter.Mode != ParameterMode.In)
{
// non input parameter must be treated as ObjectParameter instances so that the
// value can be set asynchronously (after the method has yielded and the reader
// has been consumed)
return typeof(ObjectParameter);
}
PrimitiveType parameterType = (PrimitiveType)parameter.TypeUsage.EdmType;
Type clrType = parameterType.ClrType;
return clrType;
}
private void CreateFunctionArgument(CodeMemberMethod method, UniqueIdentifierService uniqueIdentifierService, FunctionParameter parameter)
{
// get type of parameter
Type clrType = DetermineParameterType(parameter);
// parameters to stored procedures must be nullable
CodeTypeReference argumentType = clrType.IsValueType ? TypeReference.NullableForType(clrType) : TypeReference.ForType(clrType);
string parameterName = uniqueIdentifierService.AdjustIdentifier(parameter.Name, parameter);
CodeParameterDeclarationExpression codeParameter = new CodeParameterDeclarationExpression(argumentType, parameterName);
method.Parameters.Add(codeParameter);
}
private CodeExpression CreateFunctionParameter(CodeMemberMethod method, UniqueIdentifierService uniqueIdentifierService, FunctionParameter parameter)
{
// get (adjusted) name of parameter
string adjustedParameterName;
if (!uniqueIdentifierService.TryGetAdjustedName(parameter, out adjustedParameterName))
{
Debug.Fail("parameter must be registered in identifier service");
}
Type parameterType = DetermineParameterType(parameter);
// make sure the variable name does not collide with any parameters to the method, or any
// existing variables (all registered in the service)
string variableName = uniqueIdentifierService.AdjustIdentifier(parameter.Name + "Parameter");
// ObjectParameter variableName;
// if (null != parameterName)
// {
// variableName = new ObjectParameter("parameterName", adjustedParameterName);
// }
// else
// {
// variableName = new ObjectParameter("parameterName", typeof(parameterType));
// }
method.Statements.Add(
new CodeVariableDeclarationStatement(TypeReference.ForType(typeof(ObjectParameter)), variableName));
CodeExpression variableReference = new CodeVariableReferenceExpression(variableName);
CodeExpression parameterReference = new CodeVariableReferenceExpression(adjustedParameterName);
CodeStatement nullConstructor = new CodeAssignStatement(variableReference,
new CodeObjectCreateExpression(TypeReference.ForType(typeof(ObjectParameter)),
new CodePrimitiveExpression(parameter.Name),
new CodeTypeOfExpression(TypeReference.ForType(parameterType))));
CodeStatement valueConstructor = new CodeAssignStatement(variableReference,
new CodeObjectCreateExpression(TypeReference.ForType(typeof(ObjectParameter)),
new CodePrimitiveExpression(parameter.Name),
parameterReference));
CodeExpression notNullCondition;
if (parameterType.IsValueType)
{
// Value type parameters generate Nullable<ValueType> arguments (see CreateFunctionArgument).
// We call Nullable<ValueType>.HasValue to determine whether the argument passed in is null
// (since null != nullableTypeInstance does not work in VB)
//
// parameterReference.HasValue
notNullCondition = new CodePropertyReferenceExpression(
parameterReference,
"HasValue");
}
else
{
// use parameterReference != null
notNullCondition = new CodeBinaryOperatorExpression(
parameterReference,
CodeBinaryOperatorType.IdentityInequality,
NullExpression);
}
method.Statements.Add(
new CodeConditionStatement(
notNullCondition,
new CodeStatement[] { valueConstructor, },
new CodeStatement[] { nullConstructor, }
)
);
return variableReference;
}
private FunctionParameter CreateFunctionImportParameter(FunctionParameter storeParameter, UniqueIdentifierService usedParameterNames)
{
Debug.Assert(storeParameter.Mode == ParameterMode.In, "Function import mapping is supported only for 'In' parameters.");
string name = CreateModelName(storeParameter.Name, usedParameterNames);
TypeUsage cspaceTypeUsage = storeParameter.TypeUsage.GetModelTypeUsage();
var modelParameter = new FunctionParameter(name, cspaceTypeUsage, storeParameter.Mode);
return modelParameter;
}
// Adds and registers a DbParameter taking the number of rows affected
internal void RegisterRowsAffectedParameter(FunctionParameter rowsAffectedParameter)
{
if (null != rowsAffectedParameter)
{
Debug.Assert(rowsAffectedParameter.Mode == ParameterMode.Out || rowsAffectedParameter.Mode == ParameterMode.InOut,
"when loading mapping metadata, we check that the parameter is an out parameter");
m_rowsAffectedParameter = m_dbCommand.Parameters[rowsAffectedParameter.Name];
}
}
/// <summary>
/// Convert the S type function parameters and returnType to C types.
/// </summary>
private EdmFunction ConvertFunctionSignatureToCType(EdmFunction sTypeFunction)
{
Debug.Assert(sTypeFunction.DataSpace == Edm.DataSpace.SSpace, "sTypeFunction.DataSpace == Edm.DataSpace.SSpace");
if (sTypeFunction.IsFromProviderManifest)
{
return sTypeFunction;
}
FunctionParameter returnParameter = null;
if (sTypeFunction.ReturnParameter != null)
{
TypeUsage edmTypeUsageReturnParameter =
MetadataHelper.ConvertStoreTypeUsageToEdmTypeUsage(sTypeFunction.ReturnParameter.TypeUsage);
returnParameter =
new FunctionParameter(
sTypeFunction.ReturnParameter.Name,
edmTypeUsageReturnParameter,
sTypeFunction.ReturnParameter.GetParameterMode());
}
List<FunctionParameter> parameters = new List<FunctionParameter>();
if (sTypeFunction.Parameters.Count > 0)
{
foreach (var parameter in sTypeFunction.Parameters)
{
TypeUsage edmTypeUsage = MetadataHelper.ConvertStoreTypeUsageToEdmTypeUsage(parameter.TypeUsage);
FunctionParameter edmTypeParameter = new FunctionParameter(parameter.Name, edmTypeUsage, parameter.GetParameterMode());
parameters.Add(edmTypeParameter);
}
}
FunctionParameter[] returnParameters =
returnParameter == null ? new FunctionParameter[0] : new FunctionParameter[] { returnParameter };
EdmFunction edmFunction = new EdmFunction(sTypeFunction.Name,
sTypeFunction.NamespaceName,
DataSpace.CSpace,
new EdmFunctionPayload
{
Schema = sTypeFunction.Schema,
StoreFunctionName = sTypeFunction.StoreFunctionNameAttribute,
CommandText = sTypeFunction.CommandTextAttribute,
IsAggregate = sTypeFunction.AggregateAttribute,
IsBuiltIn = sTypeFunction.BuiltInAttribute,
IsNiladic = sTypeFunction.NiladicFunctionAttribute,
IsComposable = sTypeFunction.IsComposableAttribute,
IsFromProviderManifest = sTypeFunction.IsFromProviderManifest,
IsCachedStoreFunction = true,
IsFunctionImport = sTypeFunction.IsFunctionImport,
ReturnParameters = returnParameters,
Parameters = parameters.ToArray(),
ParameterTypeSemantics = sTypeFunction.ParameterTypeSemanticsAttribute,
});
edmFunction.SetReadOnly();
return edmFunction;
}
/// <summary>
/// This method returns the string representation of the given <paramref name="parameter"/>.
/// </summary>
/// <param name="parameter">A <see cref="FunctionParameter"/> representing the function perameter.</param>
/// <returns>The string representation of the given parameter.</returns>
protected string GetTypeString(FunctionParameter parameter)
{
return GetTypeString(parameter.TypeUsage.EdmType, true);
}