/// <summary> /// Gets the function as specified by the function key. /// All parameters are assumed to be <see cref="ParameterMode.In"/>. /// </summary> /// <param name="functionName">Name of the function</param> /// <param name="parameterTypes">types of the parameters</param> /// <param name="ignoreCase">true for case-insensitive lookup</param> /// <param name="function">The function that needs to be returned</param> /// <returns> The function as specified in the function key or null</returns> /// <exception cref="System.ArgumentNullException">if functionName or parameterTypes argument is null</exception> /// <exception cref="System.ArgumentException">if no function is found with the given name or with given input parameters</exception> internal bool TryGetFunction(string functionName, TypeUsage[] parameterTypes, bool ignoreCase, out EdmFunction function) { EntityUtil.GenericCheckArgumentNull(functionName, "functionName"); EntityUtil.GenericCheckArgumentNull(parameterTypes, "parameterTypes"); string functionIdentity = EdmFunction.BuildIdentity(functionName, parameterTypes); GlobalItem item = null; function = null; if (TryGetValue(functionIdentity, ignoreCase, out item) && Helper.IsEdmFunction(item)) { function = (EdmFunction)item; return(true); } return(false); }
internal static List <EdmSchemaError> LoadItems(DbProviderManifest manifest, IList <Schema> somSchemas, ItemCollection itemCollection) { List <EdmSchemaError> errors = new List <EdmSchemaError>(); // Convert the schema, if model schema, then we use the EDM provider manifest, otherwise use the // store provider manifest IEnumerable <GlobalItem> newGlobalItems = LoadSomSchema(somSchemas, manifest, itemCollection); List <String> tempCTypeFunctionIdentity = new List <string>(); // No errors, so go ahead and add the types and make them readonly foreach (GlobalItem globalItem in newGlobalItems) { // If multiple function parameter and return types expressed in SSpace map to the same // CSpace type (e.g., SqlServer.decimal and SqlServer.numeric both map to Edm.Decimal), // we need to guard against attempts to insert duplicate functions into the collection. // if (globalItem.BuiltInTypeKind == BuiltInTypeKind.EdmFunction && globalItem.DataSpace == DataSpace.SSpace) { EdmFunction function = (EdmFunction)globalItem; StringBuilder sb = new StringBuilder(); EdmFunction.BuildIdentity( sb, function.FullName, function.Parameters, // convert function parameters to C-side types (param) => MetadataHelper.ConvertStoreTypeUsageToEdmTypeUsage(param.TypeUsage), (param) => param.Mode); string cTypeFunctionIdentity = sb.ToString(); // Validate identity if (tempCTypeFunctionIdentity.Contains(cTypeFunctionIdentity)) { errors.Add( new EdmSchemaError( Strings.DuplicatedFunctionoverloads(function.FullName, cTypeFunctionIdentity.Substring(function.FullName.Length)).Trim() /*parameters*/, (int)ErrorCode.DuplicatedFunctionoverloads, EdmSchemaErrorSeverity.Error)); continue; } tempCTypeFunctionIdentity.Add(cTypeFunctionIdentity); } globalItem.SetReadOnly(); itemCollection.AddInternal(globalItem); } return(errors); }
/// <summary> /// Builds function identity string in the form of "functionName (param1, param2, ... paramN)". /// </summary> internal override void BuildIdentity(StringBuilder builder) { // If we've already cached the identity, simply append it if (null != CacheIdentity) { builder.Append(CacheIdentity); return; } EdmFunction.BuildIdentity( builder, FullName, Parameters, (param) => param.TypeUsage, (param) => param.Mode); }