internal bool TryGetFunctionFromMetadata(
string namespaceName,
string functionName,
out MetadataFunctionGroup functionGroup)
{
IList <EdmFunction> functionOverloads;
if (this._perspective.TryGetFunctionByName(namespaceName, functionName, this._parserOptions.NameComparisonCaseInsensitive, out functionOverloads))
{
functionGroup = new MetadataFunctionGroup(TypeResolver.GetFullName(namespaceName, functionName), functionOverloads);
return(true);
}
functionGroup = (MetadataFunctionGroup)null;
return(false);
}
internal MetadataMember ResolveMetadataMemberAccess(
MetadataMember qualifier,
string name,
ErrorContext errCtx)
{
string fullName = TypeResolver.GetFullName(qualifier.Name, name);
if (qualifier.MetadataMemberClass == MetadataMemberClass.Namespace)
{
MetadataType type;
if (this.TryGetTypeFromMetadata(fullName, out type))
{
return((MetadataMember)type);
}
MetadataFunctionGroup functionGroup;
if (this.TryGetFunctionFromMetadata(qualifier.Name, name, out functionGroup))
{
return((MetadataMember)functionGroup);
}
return((MetadataMember) new MetadataNamespace(fullName));
}
if (qualifier.MetadataMemberClass == MetadataMemberClass.Type)
{
MetadataType metadataType = (MetadataType)qualifier;
if (TypeSemantics.IsEnumerationType(metadataType.TypeUsage))
{
EnumMember outMember;
if (this._perspective.TryGetEnumMember((EnumType)metadataType.TypeUsage.EdmType, name, this._parserOptions.NameComparisonCaseInsensitive, out outMember))
{
return((MetadataMember) new MetadataEnumMember(fullName, metadataType.TypeUsage, outMember));
}
string errorMessage = Strings.NotAMemberOfType((object)name, (object)qualifier.Name);
throw EntitySqlException.Create(errCtx, errorMessage, (Exception)null);
}
}
string errorMessage1 = Strings.InvalidMetadataMemberClassResolution((object)qualifier.Name, (object)qualifier.MetadataMemberClassName, (object)MetadataNamespace.NamespaceClassName);
throw EntitySqlException.Create(errCtx, errorMessage1, (Exception)null);
}
/// <summary>
/// Try resolving multipart identifier as an alternative name of a group key (see SemanticAnalyzer.ProcessGroupByClause(...) for more info).
/// </summary>
internal bool TryResolveDotExprAsGroupKeyAlternativeName(DotExpr dotExpr, out ValueExpression groupKeyResolution)
{
groupKeyResolution = null;
string[] names;
ScopeEntry scopeEntry;
int scopeIndex;
if (IsInAnyGroupScope()
&&
dotExpr.IsMultipartIdentifier(out names)
&&
TryScopeLookup(TypeResolver.GetFullName(names), out scopeEntry, out scopeIndex))
{
var iGetAlternativeName = scopeEntry as IGetAlternativeName;
//
// Accept only if names[] match alternative name part by part.
//
if (iGetAlternativeName != null &&
iGetAlternativeName.AlternativeName != null
&&
names.SequenceEqual(iGetAlternativeName.AlternativeName, NameComparer))
{
//
// Set correlation flag
//
SetScopeRegionCorrelationFlag(scopeIndex);
groupKeyResolution =
new ValueExpression(
GetExpressionFromScopeEntry(scopeEntry, scopeIndex, TypeResolver.GetFullName(names), dotExpr.ErrCtx));
return(true);
}
}
return(false);
}
internal bool TryResolveDotExprAsGroupKeyAlternativeName(
DotExpr dotExpr,
out ValueExpression groupKeyResolution)
{
groupKeyResolution = (ValueExpression)null;
string[] names;
ScopeEntry scopeEntry;
int scopeIndex;
if (this.IsInAnyGroupScope() && dotExpr.IsMultipartIdentifier(out names) && this.TryScopeLookup(TypeResolver.GetFullName(names), out scopeEntry, out scopeIndex))
{
IGetAlternativeName getAlternativeName = scopeEntry as IGetAlternativeName;
if (getAlternativeName != null && getAlternativeName.AlternativeName != null && ((IEnumerable <string>)names).SequenceEqual <string>((IEnumerable <string>)getAlternativeName.AlternativeName, (IEqualityComparer <string>) this.NameComparer))
{
this.SetScopeRegionCorrelationFlag(scopeIndex);
groupKeyResolution = new ValueExpression(this.GetExpressionFromScopeEntry(scopeEntry, scopeIndex, TypeResolver.GetFullName(names), dotExpr.ErrCtx));
return(true);
}
}
return(false);
}
internal MetadataMember ResolveUnqualifiedName(
string name,
bool partOfQualifiedName,
ErrorContext errCtx)
{
bool flag1 = partOfQualifiedName && this._resolveLeftMostUnqualifiedNameAsNamespaceOnly;
bool flag2 = !partOfQualifiedName;
InlineFunctionGroup inlineFunctionGroup;
if (!flag1 && flag2 && this.TryGetInlineFunction(name, out inlineFunctionGroup))
{
return((MetadataMember)inlineFunctionGroup);
}
MetadataNamespace metadataNamespace;
if (this._aliasedNamespaces.TryGetValue(name, out metadataNamespace))
{
return((MetadataMember)metadataNamespace);
}
if (!flag1)
{
MetadataType type1 = (MetadataType)null;
MetadataFunctionGroup functionGroup1 = (MetadataFunctionGroup)null;
if (!this.TryGetTypeFromMetadata(name, out type1) && flag2)
{
string[] strArray = name.Split('.');
if (strArray.Length > 1 && ((IEnumerable <string>)strArray).All <string>((Func <string, bool>)(p => p.Length > 0)))
{
string functionName = strArray[strArray.Length - 1];
this.TryGetFunctionFromMetadata(name.Substring(0, name.Length - functionName.Length - 1), functionName, out functionGroup1);
}
}
MetadataNamespace ns2 = (MetadataNamespace)null;
foreach (MetadataNamespace ns1 in this._namespaces)
{
MetadataType type2;
if (this.TryGetTypeFromMetadata(TypeResolver.GetFullName(ns1.Name, name), out type2))
{
if (type1 != null || functionGroup1 != null)
{
throw TypeResolver.AmbiguousMetadataMemberName(errCtx, name, ns1, ns2);
}
type1 = type2;
ns2 = ns1;
}
MetadataFunctionGroup functionGroup2;
if (flag2 && this.TryGetFunctionFromMetadata(ns1.Name, name, out functionGroup2))
{
if (type1 != null || functionGroup1 != null)
{
throw TypeResolver.AmbiguousMetadataMemberName(errCtx, name, ns1, ns2);
}
functionGroup1 = functionGroup2;
ns2 = ns1;
}
}
if (type1 != null)
{
return((MetadataMember)type1);
}
if (functionGroup1 != null)
{
return((MetadataMember)functionGroup1);
}
}
return((MetadataMember) new MetadataNamespace(name));
}
