Files
mono/mcs/class/referencesource/System.Data.Entity/System/Data/EntityModel/SchemaObjectModel/Function.cs
T
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

795 lines
27 KiB
C#

//---------------------------------------------------------------------
// <copyright file="Function.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//
// @owner [....]
// @backupOwner [....]
//---------------------------------------------------------------------
namespace System.Data.EntityModel.SchemaObjectModel
{
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Data.Entity;
using System.Data.Metadata.Edm;
using System.Diagnostics;
using System.Xml;
/// <summary>
/// class representing the Schema element in the schema
/// </summary>
internal class Function : SchemaType
{
#region Instance Fields
// if adding properties also add to InitializeObject()!
private bool _isAggregate = false;
private bool _isBuiltIn = false;
private bool _isNiladicFunction = false;
protected bool _isComposable = true;
protected FunctionCommandText _commandText = null;
private string _storeFunctionName = null;
protected SchemaType _type = null;
private string _unresolvedType = null;
protected bool _isRefType = false;
// both are not specified
protected SchemaElementLookUpTable<Parameter> _parameters = null;
protected List<ReturnType> _returnTypeList = null;
private CollectionKind _returnTypeCollectionKind = CollectionKind.None;
private ParameterTypeSemantics _parameterTypeSemantics;
private string _schema;
private string _functionStrongName;
#endregion
#region Static Fields
private static System.Text.RegularExpressions.Regex s_typeParser = new System.Text.RegularExpressions.Regex(@"^(?<modifier>((Collection)|(Ref)))\s*\(\s*(?<typeName>\S*)\s*\)$", System.Text.RegularExpressions.RegexOptions.Compiled);
/// <summary>
///
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
internal static void RemoveTypeModifier(ref string type, out TypeModifier typeModifier, out bool isRefType)
{
isRefType = false;
typeModifier = TypeModifier.None;
System.Text.RegularExpressions.Match match = s_typeParser.Match(type);
if (match.Success)
{
type = match.Groups["typeName"].Value;
switch (match.Groups["modifier"].Value)
{
case "Collection":
typeModifier = TypeModifier.Array;
return;
case "Ref":
isRefType = true;
return;
default:
Debug.Assert(false, "Unexpected modifier: " + match.Groups["modifier"].Value);
break;
}
}
}
internal static string GetTypeNameForErrorMessage(SchemaType type, CollectionKind colKind, bool isRef)
{
string typeName = type.FQName;
if (isRef)
{
typeName = "Ref(" + typeName + ")";
}
switch (colKind)
{
case CollectionKind.Bag:
typeName = "Collection(" + typeName + ")";
break;
default:
Debug.Assert(colKind == CollectionKind.None, "Unexpected CollectionKind");
break;
}
return typeName;
}
#endregion
#region Public Methods
/// <summary>
/// ctor for a schema function
/// </summary>
public Function(Schema parentElement)
: base(parentElement)
{
}
#endregion
#region Public Properties
public bool IsAggregate
{
get
{
return _isAggregate;
}
internal set
{
_isAggregate = value;
}
}
public bool IsBuiltIn
{
get
{
return _isBuiltIn;
}
internal set
{
_isBuiltIn = value;
}
}
public bool IsNiladicFunction
{
get
{
return _isNiladicFunction;
}
internal set
{
_isNiladicFunction = value;
}
}
public bool IsComposable
{
get
{
return _isComposable;
}
internal set
{
_isComposable = value;
}
}
public string CommandText
{
get
{
if (_commandText != null)
{
return _commandText.CommandText;
}
return null;
}
}
public ParameterTypeSemantics ParameterTypeSemantics
{
get
{
return _parameterTypeSemantics;
}
internal set
{
_parameterTypeSemantics = value;
}
}
public string StoreFunctionName
{
get
{
return _storeFunctionName;
}
internal set
{
Debug.Assert(value != null, "StoreFunctionName should never be set null value");
_storeFunctionName = value;
}
}
public virtual SchemaType Type
{
get
{
if (null != _returnTypeList)
{
Debug.Assert(_returnTypeList.Count == 1, "Shouldn't use Type if there could be multiple return types");
return this._returnTypeList[0].Type;
}
else
{
return this._type;
}
}
}
public IList<ReturnType> ReturnTypeList
{
get
{
return null != _returnTypeList ? new ReadOnlyCollection<ReturnType>(_returnTypeList) : null;
}
}
public SchemaElementLookUpTable<Parameter> Parameters
{
get
{
if (_parameters == null)
{
_parameters = new SchemaElementLookUpTable<Parameter>();
}
return _parameters;
}
}
public CollectionKind CollectionKind
{
get
{
return _returnTypeCollectionKind;
}
internal set
{
_returnTypeCollectionKind = value;
}
}
public override string Identity
{
get
{
if (String.IsNullOrEmpty(_functionStrongName))
{
string name = this.FQName;
System.Text.StringBuilder stringBuilder = new Text.StringBuilder(name);
bool first = true;
stringBuilder.Append('(');
foreach (Parameter parameter in this.Parameters)
{
if (!first)
{
stringBuilder.Append(',');
}
else
{
first = false;
}
stringBuilder.Append(Helper.ToString(parameter.ParameterDirection));
stringBuilder.Append(' ');
// we don't include the facets in the identity, since we are *not*
// taking them into consideration inside the
// RankFunctionParameters method of TypeResolver.cs
parameter.WriteIdentity(stringBuilder);
}
stringBuilder.Append(')');
_functionStrongName = stringBuilder.ToString();
}
return _functionStrongName;
}
}
public bool IsReturnAttributeReftype
{
get
{
return _isRefType;
}
}
public virtual bool IsFunctionImport { get { return false; } }
public string DbSchema
{
get
{
return _schema;
}
}
#endregion
#region Protected Properties
protected override bool HandleElement(XmlReader reader)
{
if (base.HandleElement(reader))
{
return true;
}
else if (CanHandleElement(reader, XmlConstants.CommandText))
{
HandleCommandTextFunctionElment(reader);
return true;
}
else if (CanHandleElement(reader, XmlConstants.Parameter))
{
HandleParameterElement(reader);
return true;
}
else if (CanHandleElement(reader, XmlConstants.ReturnTypeElement))
{
HandleReturnTypeElement(reader);
return true;
}
else if (Schema.DataModel == SchemaDataModelOption.EntityDataModel)
{
if (CanHandleElement(reader, XmlConstants.ValueAnnotation))
{
// EF does not support this EDM 3.0 element, so ignore it.
SkipElement(reader);
return true;
}
else if (CanHandleElement(reader, XmlConstants.TypeAnnotation))
{
// EF does not support this EDM 3.0 element, so ignore it.
SkipElement(reader);
return true;
}
}
return false;
}
protected override bool HandleAttribute(XmlReader reader)
{
if (base.HandleAttribute(reader))
{
return true;
}
else if (CanHandleAttribute(reader, XmlConstants.ReturnType))
{
HandleReturnTypeAttribute(reader);
return true;
}
else if (CanHandleAttribute(reader, XmlConstants.AggregateAttribute))
{
HandleAggregateAttribute(reader);
return true;
}
else if (CanHandleAttribute(reader, XmlConstants.BuiltInAttribute))
{
HandleBuiltInAttribute(reader);
return true;
}
else if (CanHandleAttribute(reader, XmlConstants.StoreFunctionName))
{
HandleStoreFunctionNameAttribute(reader);
return true;
}
else if (CanHandleAttribute(reader, XmlConstants.NiladicFunction))
{
HandleNiladicFunctionAttribute(reader);
return true;
}
else if (CanHandleAttribute(reader, XmlConstants.IsComposable))
{
HandleIsComposableAttribute(reader);
return true;
}
else if (CanHandleAttribute(reader, XmlConstants.ParameterTypeSemantics))
{
HandleParameterTypeSemanticsAttribute(reader);
return true;
}
else if (CanHandleAttribute(reader, XmlConstants.Schema))
{
HandleDbSchemaAttribute(reader);
return true;
}
return false;
}
#endregion
#region Internal Methods
internal override void ResolveTopLevelNames()
{
base.ResolveTopLevelNames();
if (_unresolvedType != null)
{
Debug.Assert(Schema.DataModel != SchemaDataModelOption.ProviderManifestModel, "ProviderManifest cannot have ReturnType as an attribute");
Schema.ResolveTypeName(this, UnresolvedReturnType, out _type);
}
if (null != _returnTypeList)
{
foreach (ReturnType returnType in _returnTypeList)
{
returnType.ResolveTopLevelNames();
}
}
foreach (Parameter parameter in this.Parameters)
{
parameter.ResolveTopLevelNames();
}
}
/// <summary>
/// Perform local validation on function definition.
/// </summary>
internal override void Validate()
{
base.Validate();
if (_type != null && _returnTypeList != null)
{
AddError(ErrorCode.ReturnTypeDeclaredAsAttributeAndElement, EdmSchemaErrorSeverity.Error, Strings.TypeDeclaredAsAttributeAndElement);
}
// only call Type if _returnTypeList is empty, to ensure that we don't it when
// _returnTypeList has more than one element.
if (this._returnTypeList == null && this.Type == null)
{
// Composable functions and function imports must declare return type.
if (this.IsComposable)
{
AddError(ErrorCode.ComposableFunctionOrFunctionImportWithoutReturnType, EdmSchemaErrorSeverity.Error,
Strings.ComposableFunctionOrFunctionImportMustDeclareReturnType);
}
}
else
{
// Non-composable functions (except function imports) must not declare a return type.
if (!this.IsComposable && !this.IsFunctionImport)
{
AddError(ErrorCode.NonComposableFunctionWithReturnType, EdmSchemaErrorSeverity.Error,
Strings.NonComposableFunctionMustNotDeclareReturnType);
}
}
if (Schema.DataModel != SchemaDataModelOption.EntityDataModel)
{
if (IsAggregate)
{
// Make sure that the function has exactly one parameter and that takes
// a collection type
if (Parameters.Count != 1)
{
AddError(ErrorCode.InvalidNumberOfParametersForAggregateFunction,
EdmSchemaErrorSeverity.Error,
this,
System.Data.Entity.Strings.InvalidNumberOfParametersForAggregateFunction(FQName));
}
else if (Parameters.GetElementAt(0).CollectionKind == CollectionKind.None)
{
// Since we have already checked that there should be exactly one parameter, it should be safe to get the
// first parameter for the function
Parameter param = Parameters.GetElementAt(0);
AddError(ErrorCode.InvalidParameterTypeForAggregateFunction,
EdmSchemaErrorSeverity.Error,
this,
System.Data.Entity.Strings.InvalidParameterTypeForAggregateFunction(param.Name, FQName));
}
}
if (!this.IsComposable)
{
// All aggregates, built-in and niladic functions must be composable, so throw error here.
if (this.IsAggregate ||
this.IsNiladicFunction ||
this.IsBuiltIn)
{
AddError(ErrorCode.NonComposableFunctionAttributesNotValid, EdmSchemaErrorSeverity.Error,
Strings.NonComposableFunctionHasDisallowedAttribute);
}
}
if (null != this.CommandText)
{
// Functions with command text are not composable.
if (this.IsComposable)
{
AddError(ErrorCode.ComposableFunctionWithCommandText, EdmSchemaErrorSeverity.Error,
Strings.CommandTextFunctionsNotComposable);
}
// Functions with command text cannot declare store function name.
if (null != this.StoreFunctionName)
{
AddError(ErrorCode.FunctionDeclaresCommandTextAndStoreFunctionName, EdmSchemaErrorSeverity.Error,
Strings.CommandTextFunctionsCannotDeclareStoreFunctionName);
}
}
}
if (Schema.DataModel == SchemaDataModelOption.ProviderDataModel)
{
// In SSDL function may return a primitive value or a collection of rows with scalar props.
// It is not possible to encode "collection of rows" in the ReturnType attribute, so the only check needed here is to make sure that the type is scalar and not a collection.
if (_type != null && (_type is ScalarType == false || _returnTypeCollectionKind != Metadata.Edm.CollectionKind.None))
{
AddError(ErrorCode.FunctionWithNonPrimitiveTypeNotSupported,
EdmSchemaErrorSeverity.Error,
this,
System.Data.Entity.Strings.FunctionWithNonPrimitiveTypeNotSupported(GetTypeNameForErrorMessage(_type, _returnTypeCollectionKind, _isRefType), this.FQName));
}
}
if (_returnTypeList != null)
{
foreach (ReturnType returnType in _returnTypeList)
{
// FunctiomImportElement has additional validation for return types.
returnType.Validate();
}
}
if (_parameters != null)
{
foreach (var parameter in _parameters)
{
parameter.Validate();
}
}
if (_commandText != null)
{
_commandText.Validate();
}
}
internal override void ResolveSecondLevelNames()
{
foreach (var parameter in _parameters)
{
parameter.ResolveSecondLevelNames();
}
}
internal override SchemaElement Clone(SchemaElement parentElement)
{
// We only support clone for FunctionImports.
throw Error.NotImplemented();
}
protected void CloneSetFunctionFields(Function clone)
{
clone._isAggregate = _isAggregate;
clone._isBuiltIn = _isBuiltIn;
clone._isNiladicFunction = _isNiladicFunction;
clone._isComposable = _isComposable;
clone._commandText = _commandText;
clone._storeFunctionName = _storeFunctionName;
clone._type = _type;
clone._returnTypeList = _returnTypeList;
clone._returnTypeCollectionKind = _returnTypeCollectionKind;
clone._parameterTypeSemantics = _parameterTypeSemantics;
clone._schema = _schema;
clone.Name = this.Name;
// Clone all the parameters
foreach (Parameter parameter in this.Parameters)
{
AddErrorKind error = clone.Parameters.TryAdd((Parameter)parameter.Clone(clone));
Debug.Assert(error == AddErrorKind.Succeeded, "Since we are cloning a validated function, this should never fail.");
}
}
#endregion
#region Internal Properties
/// <summary>
///
/// </summary>
/// <value></value>
internal string UnresolvedReturnType
{
get
{
return _unresolvedType;
}
set
{
_unresolvedType = value;
}
}
#endregion //Internal Properties
#region Private Methods
/// <summary>
/// The method that is called when a DbSchema attribute is encountered.
/// </summary>
/// <param name="reader">An XmlReader positioned at the Type attribute.</param>
private void HandleDbSchemaAttribute(XmlReader reader)
{
Debug.Assert(Schema.DataModel == SchemaDataModelOption.ProviderDataModel, "We shouldn't see this attribute unless we are parsing ssdl");
Debug.Assert(reader != null);
_schema = reader.Value;
}
/// <summary>
/// Handler for the Version attribute
/// </summary>
/// <param name="reader">xml reader currently positioned at Version attribute</param>
private void HandleAggregateAttribute(XmlReader reader)
{
Debug.Assert(reader != null);
bool isAggregate = false;
HandleBoolAttribute(reader, ref isAggregate);
IsAggregate = isAggregate;
}
/// <summary>
/// Handler for the Namespace attribute
/// </summary>
/// <param name="reader">xml reader currently positioned at Namespace attribute</param>
private void HandleBuiltInAttribute(XmlReader reader)
{
Debug.Assert(reader != null);
bool isBuiltIn = false;
HandleBoolAttribute(reader, ref isBuiltIn);
IsBuiltIn = isBuiltIn;
}
/// <summary>
/// Handler for the Alias attribute
/// </summary>
/// <param name="reader">xml reader currently positioned at Alias attribute</param>
private void HandleStoreFunctionNameAttribute(XmlReader reader)
{
Debug.Assert(reader != null);
string value = reader.Value.ToString();
if (!String.IsNullOrEmpty(value))
{
value = value.Trim();
StoreFunctionName = value;
}
}
/// <summary>
/// Handler for the NiladicFunctionAttribute attribute
/// </summary>
/// <param name="reader">xml reader currently positioned at Namespace attribute</param>
private void HandleNiladicFunctionAttribute(XmlReader reader)
{
Debug.Assert(reader != null);
bool isNiladicFunction = false;
HandleBoolAttribute(reader, ref isNiladicFunction);
IsNiladicFunction = isNiladicFunction;
}
/// <summary>
/// Handler for the IsComposableAttribute attribute
/// </summary>
/// <param name="reader">xml reader currently positioned at Namespace attribute</param>
private void HandleIsComposableAttribute(XmlReader reader)
{
Debug.Assert(reader != null);
bool isComposable = true;
HandleBoolAttribute(reader, ref isComposable);
IsComposable = isComposable;
}
private void HandleCommandTextFunctionElment(XmlReader reader)
{
Debug.Assert(reader != null);
FunctionCommandText commandText = new FunctionCommandText(this);
commandText.Parse(reader);
_commandText = commandText;
}
protected virtual void HandleReturnTypeAttribute(XmlReader reader)
{
Debug.Assert(reader != null);
Debug.Assert(UnresolvedReturnType == null);
string type;
if (!Utils.GetString(Schema, reader, out type))
return;
TypeModifier typeModifier;
RemoveTypeModifier(ref type, out typeModifier, out _isRefType);
switch (typeModifier)
{
case TypeModifier.Array:
CollectionKind = CollectionKind.Bag;
break;
case TypeModifier.None:
break;
default:
Debug.Assert(false, "RemoveTypeModifier already checks for this");
break;
}
if (!Utils.ValidateDottedName(Schema, reader, type))
return;
UnresolvedReturnType = type;
}
/// <summary>
/// Handler for the Parameter Element
/// </summary>
/// <param name="reader">xml reader currently positioned at Parameter Element</param>
protected void HandleParameterElement(XmlReader reader)
{
Debug.Assert(reader != null);
Parameter parameter = new Parameter(this);
parameter.Parse(reader);
Parameters.Add(parameter, true, Strings.ParameterNameAlreadyDefinedDuplicate);
}
/// <summary>
/// Handler for the ReturnType element
/// </summary>
/// <param name="reader">xml reader currently positioned at ReturnType element</param>
protected void HandleReturnTypeElement(XmlReader reader)
{
Debug.Assert(reader != null);
ReturnType returnType = new ReturnType(this);
returnType.Parse(reader);
if (this._returnTypeList == null)
{
this._returnTypeList = new List<ReturnType>();
}
this._returnTypeList.Add(returnType);
}
/// <summary>
/// Handles ParameterTypeSemantics attribute
/// </summary>
/// <param name="reader"></param>
private void HandleParameterTypeSemanticsAttribute(XmlReader reader)
{
Debug.Assert(reader != null);
string value = reader.Value;
if (String.IsNullOrEmpty(value))
{
return;
}
value = value.Trim();
if (!String.IsNullOrEmpty(value))
{
switch (value)
{
case "ExactMatchOnly":
ParameterTypeSemantics = ParameterTypeSemantics.ExactMatchOnly;
break;
case "AllowImplicitPromotion":
ParameterTypeSemantics = ParameterTypeSemantics.AllowImplicitPromotion;
break;
case "AllowImplicitConversion":
ParameterTypeSemantics = ParameterTypeSemantics.AllowImplicitConversion;
break;
default:
// don't try to use the name of the function, because we are still parsing the
// attributes, and we may not be to the name attribute yet.
AddError(ErrorCode.InvalidValueForParameterTypeSemantics, EdmSchemaErrorSeverity.Error, reader,
System.Data.Entity.Strings.InvalidValueForParameterTypeSemanticsAttribute(
value));
break;
}
}
}
#endregion
}
}