/// <summary>
/// Adds a non-aliased namespace import.
/// </summary>
internal void AddNamespaceImport(MetadataNamespace @namespace, ErrorContext errCtx)
{
if (_namespaces.Contains(@namespace))
{
throw EntityUtil.EntitySqlError(errCtx, Strings.NamespaceAlreadyImported(@namespace.Name));
}
_namespaces.Add(@namespace);
}
/// <summary>
/// Adds an aliased namespace import.
/// </summary>
internal void AddAliasedNamespaceImport(string alias, MetadataNamespace @namespace, ErrorContext errCtx)
{
if (_aliasedNamespaces.ContainsKey(alias))
{
throw EntityUtil.EntitySqlError(errCtx, Strings.NamespaceAliasAlreadyUsed(alias));
}
_aliasedNamespaces.Add(alias, @namespace);
}
private static Exception AmbiguousMetadataMemberName(ErrorContext errCtx, string name, MetadataNamespace ns1, MetadataNamespace ns2)
{
throw EntityUtil.EntitySqlError(errCtx, Strings.AmbiguousMetadataMemberName(name, ns1.Name, ns2 != null ? ns2.Name : null));
}
internal MetadataMember ResolveUnqualifiedName(string name, bool partOfQualifiedName, ErrorContext errCtx)
{
Debug.Assert(!String.IsNullOrEmpty(name), "name must not be empty");
//
// In the case of Name1.Name2...NameN and if backward compatibility mode is on, then resolve Name1 as namespace only, ignore any other possible resolutions.
//
bool resolveAsNamespaceOnly = partOfQualifiedName && _resolveLeftMostUnqualifiedNameAsNamespaceOnly;
//
// In the case of Name1.Name2...NameN, ignore functions while resolving Name1: functions don't have members.
//
bool includeFunctions = !partOfQualifiedName;
//
// Try resolving as an inline function.
//
InlineFunctionGroup inlineFunctionGroup;
if (!resolveAsNamespaceOnly &&
includeFunctions && TryGetInlineFunction(name, out inlineFunctionGroup))
{
return(inlineFunctionGroup);
}
//
// Try resolving as a namespace alias.
//
MetadataNamespace aliasedNamespaceImport;
if (_aliasedNamespaces.TryGetValue(name, out aliasedNamespaceImport))
{
return(aliasedNamespaceImport);
}
if (!resolveAsNamespaceOnly)
{
//
// Try resolving as a type or functionGroup in the global namespace or as an imported member.
// Throw if ambiguous.
//
MetadataType type = null;
MetadataFunctionGroup functionGroup = null;
if (!TryGetTypeFromMetadata(name, out type))
{
if (includeFunctions)
{
//
// If name looks like a multipart identifier, try resolving it in the global namespace.
// Escaped multipart identifiers usually appear in views: select [NS1.NS2.Product](...) from ...
//
var multipart = name.Split('.');
if (multipart.Length > 1 && multipart.All(p => p.Length > 0))
{
var functionName = multipart[multipart.Length - 1];
var namespaceName = name.Substring(0, name.Length - functionName.Length - 1);
TryGetFunctionFromMetadata(namespaceName, functionName, out functionGroup);
}
}
}
//
// Try resolving as an imported member.
//
MetadataNamespace importedMemberNamespace = null;
foreach (MetadataNamespace namespaceImport in _namespaces)
{
string fullName = GetFullName(namespaceImport.Name, name);
MetadataType importedType;
if (TryGetTypeFromMetadata(fullName, out importedType))
{
if (type == null && functionGroup == null)
{
type = importedType;
importedMemberNamespace = namespaceImport;
}
else
{
throw AmbiguousMetadataMemberName(errCtx, name, namespaceImport, importedMemberNamespace);
}
}
MetadataFunctionGroup importedFunctionGroup;
if (includeFunctions && TryGetFunctionFromMetadata(namespaceImport.Name, name, out importedFunctionGroup))
{
if (type == null && functionGroup == null)
{
functionGroup = importedFunctionGroup;
importedMemberNamespace = namespaceImport;
}
else
{
throw AmbiguousMetadataMemberName(errCtx, name, namespaceImport, importedMemberNamespace);
}
}
}
if (type != null)
{
return(type);
}
if (functionGroup != null)
{
return(functionGroup);
}
}
//
// Otherwise, resolve as a namespace.
//
return(new MetadataNamespace(name));
}