internal void AddNamespaceImport(MetadataNamespace @namespace, ErrorContext errCtx) { if (this._namespaces.Contains(@namespace)) { string errorMessage = Strings.NamespaceAlreadyImported((object)@namespace.Name); throw EntitySqlException.Create(errCtx, errorMessage, (Exception)null); } this._namespaces.Add(@namespace); }
// <summary> // Adds an aliased namespace import. // </summary> internal void AddAliasedNamespaceImport(string alias, MetadataNamespace @namespace, ErrorContext errCtx) { if (_aliasedNamespaces.ContainsKey(alias)) { var message = Strings.NamespaceAliasAlreadyUsed(alias); throw EntitySqlException.Create(errCtx, message, null); } _aliasedNamespaces.Add(alias, @namespace); }
// <summary> // Adds a non-aliased namespace import. // </summary> internal void AddNamespaceImport(MetadataNamespace @namespace, ErrorContext errCtx) { if (_namespaces.Contains(@namespace)) { var message = Strings.NamespaceAlreadyImported(@namespace.Name); throw EntitySqlException.Create(errCtx, message, null); } _namespaces.Add(@namespace); }
private static Exception AmbiguousMetadataMemberName( ErrorContext errCtx, string name, MetadataNamespace ns1, MetadataNamespace ns2) { string errorMessage = Strings.AmbiguousMetadataMemberName((object)name, (object)ns1.Name, (object)ns2?.Name); throw EntitySqlException.Create(errCtx, errorMessage, (Exception)null); }
internal void AddAliasedNamespaceImport( string alias, MetadataNamespace @namespace, ErrorContext errCtx) { if (this._aliasedNamespaces.ContainsKey(alias)) { string errorMessage = Strings.NamespaceAliasAlreadyUsed((object)alias); throw EntitySqlException.Create(errCtx, errorMessage, (Exception)null); } this._aliasedNamespaces.Add(alias, @namespace); }
private static Exception AmbiguousMetadataMemberName(ErrorContext errCtx, string name, MetadataNamespace ns1, MetadataNamespace ns2) { var message = Strings.AmbiguousMetadataMemberName(name, ns1.Name, ns2 != null ? ns2.Name : null); throw EntitySqlException.Create(errCtx, message, null); }
internal MetadataMember ResolveUnqualifiedName(string name, bool partOfQualifiedName, ErrorContext errCtx) { DebugCheck.NotEmpty(name); // // 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. // var resolveAsNamespaceOnly = partOfQualifiedName && _resolveLeftMostUnqualifiedNameAsNamespaceOnly; // // In the case of Name1.Name2...NameN, ignore functions while resolving Name1: functions don't have members. // var 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 (var namespaceImport in _namespaces) { var 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)); }
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)); }