YQL-20086 sql/v1

commit_hash:55bc611cdaa0d8a0fc3c4c7708ed9f17cc4976cf

1 files changed, 191 insertions, 191 deletions

diff --git a/yql/essentials/sql/v1/complete/sql_complete.cpp b/yql/essentials/sql/v1/complete/sql_complete.cpp
index fc8db52af13..401588dc594 100644
--- a/yql/essentials/sql/v1/complete/sql_complete.cpp
+++ b/yql/essentials/sql/v1/complete/sql_complete.cpp
@@ -21,238 +21,238 @@
 
 namespace NSQLComplete {
 
-    TString TCandidate::FilterText() const {
-        TStringBuf text = Content;
-        if (IsQuoted(text)) {
-            text = Unquoted(text);
-        }
-        return ToLowerUTF8(text);
+TString TCandidate::FilterText() const {
+    TStringBuf text = Content;
+    if (IsQuoted(text)) {
+        text = Unquoted(text);
     }
+    return ToLowerUTF8(text);
+}
 
-    class TSqlCompletionEngine: public ISqlCompletionEngine {
-    public:
-        TSqlCompletionEngine(
-            TLexerSupplier lexer,
-            INameService::TPtr names,
-            IRanking::TPtr ranking,
-            TConfiguration configuration)
-            : Configuration_(std::move(configuration))
-            , SyntaxAnalysis_(MakeLocalSyntaxAnalysis(
-                  lexer,
-                  Configuration_.IgnoredRules_,
-                  Configuration_.DisabledPreviousByToken_,
-                  Configuration_.ForcedPreviousByToken_))
-            , GlobalAnalysis_(MakeGlobalAnalysis())
-            , Names_(std::move(names))
-            , Ranking_(std::move(ranking))
-        {
-            Ranking_ = Ranking_ ? Ranking_ : MakeDummyRanking();
-        }
-
-        NThreading::TFuture<TCompletion>
-        Complete(TCompletionInput input, TEnvironment env = {}) override {
-            return CompleteAsync(input, env);
-        }
-
-        NThreading::TFuture<TCompletion> CompleteAsync(TCompletionInput input, TEnvironment env) override {
-            if ((input.CursorPosition < input.Text.length() &&
-                 IsUTF8ContinuationByte(input.Text.at(input.CursorPosition))) ||
-                (input.Text.length() < input.CursorPosition)) {
-                ythrow yexception()
-                    << "invalid cursor position " << input.CursorPosition
-                    << " for input size " << input.Text.size();
-            }
-
-            TLocalSyntaxContext local = SyntaxAnalysis_->Analyze(input);
+class TSqlCompletionEngine: public ISqlCompletionEngine {
+public:
+    TSqlCompletionEngine(
+        TLexerSupplier lexer,
+        INameService::TPtr names,
+        IRanking::TPtr ranking,
+        TConfiguration configuration)
+        : Configuration_(std::move(configuration))
+        , SyntaxAnalysis_(MakeLocalSyntaxAnalysis(
+              lexer,
+              Configuration_.IgnoredRules_,
+              Configuration_.DisabledPreviousByToken_,
+              Configuration_.ForcedPreviousByToken_))
+        , GlobalAnalysis_(MakeGlobalAnalysis())
+        , Names_(std::move(names))
+        , Ranking_(std::move(ranking))
+    {
+        Ranking_ = Ranking_ ? Ranking_ : MakeDummyRanking();
+    }
 
-            TGlobalContext global = GlobalAnalysis_->Analyze(input, std::move(env));
+    NThreading::TFuture<TCompletion>
+    Complete(TCompletionInput input, TEnvironment env = {}) override {
+        return CompleteAsync(input, env);
+    }
 
-            local = Enriched(std::move(local), global);
+    NThreading::TFuture<TCompletion> CompleteAsync(TCompletionInput input, TEnvironment env) override {
+        if ((input.CursorPosition < input.Text.length() &&
+             IsUTF8ContinuationByte(input.Text.at(input.CursorPosition))) ||
+            (input.Text.length() < input.CursorPosition)) {
+            ythrow yexception()
+                << "invalid cursor position " << input.CursorPosition
+                << " for input size " << input.Text.size();
+        }
 
-            TNameRequest request = NameRequestFrom(input, local, global);
-            if (request.IsEmpty()) {
-                return NThreading::MakeFuture<TCompletion>({
-                    .CompletedToken = GetCompletedToken(input, local.ReplaceRange),
-                    .Candidates = {},
-                });
-            }
+        TLocalSyntaxContext local = SyntaxAnalysis_->Analyze(input);
 
-            TVector<INameService::TPtr> children;
+        TGlobalContext global = GlobalAnalysis_->Analyze(input, std::move(env));
 
-            if (!local.IsQuoted) {
-                children.emplace_back(MakeBindingNameService(std::move(global.Names)));
-            }
+        local = Enriched(std::move(local), global);
 
-            if (!local.Binding && global.Column) {
-                children.emplace_back(MakeColumnNameService(std::move(global.Column->Columns)));
-            }
+        TNameRequest request = NameRequestFrom(input, local, global);
+        if (request.IsEmpty()) {
+            return NThreading::MakeFuture<TCompletion>({
+                .CompletedToken = GetCompletedToken(input, local.ReplaceRange),
+                .Candidates = {},
+            });
+        }
 
-            if (!local.Binding) {
-                children.emplace_back(Names_);
-            }
+        TVector<INameService::TPtr> children;
 
-            INameService::TPtr service =
-                MakeColumnReplicatingService(
-                    MakeUnionNameService(std::move(children), Ranking_),
-                    Ranking_);
+        if (!local.IsQuoted) {
+            children.emplace_back(MakeBindingNameService(std::move(global.Names)));
+        }
 
-            return service
-                ->Lookup(std::move(request))
-                .Apply([this, input, local = std::move(local)](auto f) {
-                    return ToCompletion(input, std::move(local), f.ExtractValue());
-                });
+        if (!local.Binding && global.Column) {
+            children.emplace_back(MakeColumnNameService(std::move(global.Column->Columns)));
         }
 
-    private:
-        TCompletedToken GetCompletedToken(TCompletionInput input, TEditRange editRange) const {
-            return {
-                .Content = input.Text.SubStr(editRange.Begin, editRange.Length),
-                .SourcePosition = editRange.Begin,
-            };
+        if (!local.Binding) {
+            children.emplace_back(Names_);
         }
 
-        TNameRequest NameRequestFrom(
-            TCompletionInput input,
-            const TLocalSyntaxContext& local,
-            const TGlobalContext& global) const {
-            TNameRequest request = {
-                .Prefix = TString(GetCompletedToken(input, local.FilterRange).Content),
-                .Limit = Configuration_.Limit,
-            };
+        INameService::TPtr service =
+            MakeColumnReplicatingService(
+                MakeUnionNameService(std::move(children), Ranking_),
+                Ranking_);
 
-            for (const auto& [first, _] : local.Keywords) {
-                request.Keywords.emplace_back(first);
-            }
+        return service
+            ->Lookup(std::move(request))
+            .Apply([this, input, local = std::move(local)](auto f) {
+                return ToCompletion(input, std::move(local), f.ExtractValue());
+            });
+    }
 
-            if (local.Pragma) {
-                TPragmaName::TConstraints constraints;
-                constraints.Namespace = local.Pragma->Namespace;
-                request.Constraints.Pragma = std::move(constraints);
-            }
+private:
+    TCompletedToken GetCompletedToken(TCompletionInput input, TEditRange editRange) const {
+        return {
+            .Content = input.Text.SubStr(editRange.Begin, editRange.Length),
+            .SourcePosition = editRange.Begin,
+        };
+    }
 
-            if (local.Type) {
-                request.Constraints.Type = TTypeName::TConstraints();
-            }
+    TNameRequest NameRequestFrom(
+        TCompletionInput input,
+        const TLocalSyntaxContext& local,
+        const TGlobalContext& global) const {
+        TNameRequest request = {
+            .Prefix = TString(GetCompletedToken(input, local.FilterRange).Content),
+            .Limit = Configuration_.Limit,
+        };
+
+        for (const auto& [first, _] : local.Keywords) {
+            request.Keywords.emplace_back(first);
+        }
 
-            if (local.Function) {
-                TFunctionName::TConstraints constraints;
-                constraints.Namespace = local.Function->Namespace;
-                constraints.ReturnType = local.Function->ReturnType;
-                request.Constraints.Function = std::move(constraints);
-            }
+        if (local.Pragma) {
+            TPragmaName::TConstraints constraints;
+            constraints.Namespace = local.Pragma->Namespace;
+            request.Constraints.Pragma = std::move(constraints);
+        }
 
-            if (local.Hint) {
-                THintName::TConstraints constraints;
-                constraints.Statement = local.Hint->StatementKind;
-                request.Constraints.Hint = std::move(constraints);
-            }
+        if (local.Type) {
+            request.Constraints.Type = TTypeName::TConstraints();
+        }
 
-            if (local.Object) {
-                request.Constraints.Object = TObjectNameConstraints();
-                request.Constraints.Object->Kinds = local.Object->Kinds;
-                request.Prefix = local.Object->Path;
-            }
+        if (local.Function) {
+            TFunctionName::TConstraints constraints;
+            constraints.Namespace = local.Function->Namespace;
+            constraints.ReturnType = local.Function->ReturnType;
+            request.Constraints.Function = std::move(constraints);
+        }
 
-            if (local.Object && global.Use) {
-                request.Constraints.Object->Provider = global.Use->Provider;
-                request.Constraints.Object->Cluster = global.Use->Name;
-            }
+        if (local.Hint) {
+            THintName::TConstraints constraints;
+            constraints.Statement = local.Hint->StatementKind;
+            request.Constraints.Hint = std::move(constraints);
+        }
 
-            if (local.Object && local.Object->HasCluster()) {
-                request.Constraints.Object->Provider = local.Object->Provider;
-                request.Constraints.Object->Cluster = local.Object->Cluster;
-            }
+        if (local.Object) {
+            request.Constraints.Object = TObjectNameConstraints();
+            request.Constraints.Object->Kinds = local.Object->Kinds;
+            request.Prefix = local.Object->Path;
+        }
 
-            if (local.Cluster) {
-                TClusterName::TConstraints constraints;
-                constraints.Namespace = ""; // TODO(YQL-19747): filter by provider
-                request.Constraints.Cluster = std::move(constraints);
-            }
+        if (local.Object && global.Use) {
+            request.Constraints.Object->Provider = global.Use->Provider;
+            request.Constraints.Object->Cluster = global.Use->Name;
+        }
 
-            if (local.Column && global.Column) {
-                TMaybe<TStringBuf> table = local.Column->Table;
-                table = !table->empty() ? table : Nothing();
+        if (local.Object && local.Object->HasCluster()) {
+            request.Constraints.Object->Provider = local.Object->Provider;
+            request.Constraints.Object->Cluster = local.Object->Cluster;
+        }
 
-                request.Constraints.Column = TColumnName::TConstraints();
-                request.Constraints.Column->TableAlias = local.Column->Table;
-                request.Constraints.Column->Tables =
-                    TColumnContext(*global.Column).ExtractAliased(table).Tables;
-                request.Constraints.Column->WithoutByTableAlias = global.Column->WithoutByTableAlias;
-            }
+        if (local.Cluster) {
+            TClusterName::TConstraints constraints;
+            constraints.Namespace = ""; // TODO(YQL-19747): filter by provider
+            request.Constraints.Cluster = std::move(constraints);
+        }
 
-            return request;
+        if (local.Column && global.Column) {
+            TMaybe<TStringBuf> table = local.Column->Table;
+            table = !table->empty() ? table : Nothing();
+
+            request.Constraints.Column = TColumnName::TConstraints();
+            request.Constraints.Column->TableAlias = local.Column->Table;
+            request.Constraints.Column->Tables =
+                TColumnContext(*global.Column).ExtractAliased(table).Tables;
+            request.Constraints.Column->WithoutByTableAlias = global.Column->WithoutByTableAlias;
         }
 
-        TCompletion ToCompletion(TCompletionInput input, TLocalSyntaxContext local, TNameResponse response) const {
-            TCompletion completion = {
-                .CompletedToken = GetCompletedToken(input, local.ReplaceRange),
-                .Candidates = ToCandidate(std::move(response.RankedNames), std::move(local)),
+        return request;
+    }
+
+    TCompletion ToCompletion(TCompletionInput input, TLocalSyntaxContext local, TNameResponse response) const {
+        TCompletion completion = {
+            .CompletedToken = GetCompletedToken(input, local.ReplaceRange),
+            .Candidates = ToCandidate(std::move(response.RankedNames), std::move(local)),
+        };
+
+        if (response.NameHintLength) {
+            const auto length = *response.NameHintLength;
+            TEditRange editRange = {
+                .Begin = input.CursorPosition - length,
+                .Length = length,
             };
+            completion.CompletedToken = GetCompletedToken(input, editRange);
+        }
 
-            if (response.NameHintLength) {
-                const auto length = *response.NameHintLength;
-                TEditRange editRange = {
-                    .Begin = input.CursorPosition - length,
-                    .Length = length,
-                };
-                completion.CompletedToken = GetCompletedToken(input, editRange);
-            }
+        return completion;
+    }
 
-            return completion;
+    static TLocalSyntaxContext Enriched(TLocalSyntaxContext local, const TGlobalContext& global) {
+        TMaybe<TFunctionContext> function = global.EnclosingFunction;
+        TMaybe<TLocalSyntaxContext::TObject>& object = local.Object;
+        if (!function || !object) {
+            return local;
         }
 
-        static TLocalSyntaxContext Enriched(TLocalSyntaxContext local, const TGlobalContext& global) {
-            TMaybe<TFunctionContext> function = global.EnclosingFunction;
-            TMaybe<TLocalSyntaxContext::TObject>& object = local.Object;
-            if (!function || !object) {
-                return local;
-            }
-
-            if (TMaybe<TClusterContext> cluster = function->Cluster) {
-                object->Provider = cluster->Provider;
-                object->Cluster = cluster->Name;
-            }
+        if (TMaybe<TClusterContext> cluster = function->Cluster) {
+            object->Provider = cluster->Provider;
+            object->Cluster = cluster->Name;
+        }
 
-            auto& name = function->Name;
-            size_t number = function->ArgumentNumber;
-
-            name = NormalizeName(name);
-
-            if (name == "concat") {
-                object->Kinds = {EObjectKind::Folder, EObjectKind::Table};
-            } else if ((number == 0) &&
-                       (name == "range" || name == "like" ||
-                        name == "regexp" || name == "filter" ||
-                        name == "folder" || name == "walkfolders")) {
-                object->Kinds = {EObjectKind::Folder};
-            } else if ((number == 1 || number == 2) && (name == "range")) {
-                if (TMaybe<TString> path = function->Arg0) {
-                    object->Path = *path;
-                    object->Path.append("/");
-                }
-
-                object->Kinds = {EObjectKind::Folder, EObjectKind::Table};
+        auto& name = function->Name;
+        size_t number = function->ArgumentNumber;
+
+        name = NormalizeName(name);
+
+        if (name == "concat") {
+            object->Kinds = {EObjectKind::Folder, EObjectKind::Table};
+        } else if ((number == 0) &&
+                   (name == "range" || name == "like" ||
+                    name == "regexp" || name == "filter" ||
+                    name == "folder" || name == "walkfolders")) {
+            object->Kinds = {EObjectKind::Folder};
+        } else if ((number == 1 || number == 2) && (name == "range")) {
+            if (TMaybe<TString> path = function->Arg0) {
+                object->Path = *path;
+                object->Path.append("/");
             }
 
-            return local;
+            object->Kinds = {EObjectKind::Folder, EObjectKind::Table};
         }
 
-        TConfiguration Configuration_;
-        ILocalSyntaxAnalysis::TPtr SyntaxAnalysis_;
-        IGlobalAnalysis::TPtr GlobalAnalysis_;
-        INameService::TPtr Names_;
-        IRanking::TPtr Ranking_;
-    };
-
-    ISqlCompletionEngine::TPtr MakeSqlCompletionEngine(
-        TLexerSupplier lexer,
-        INameService::TPtr names,
-        TConfiguration configuration,
-        IRanking::TPtr ranking) {
-        return MakeHolder<TSqlCompletionEngine>(
-            lexer, std::move(names), std::move(ranking), std::move(configuration));
+        return local;
     }
 
+    TConfiguration Configuration_;
+    ILocalSyntaxAnalysis::TPtr SyntaxAnalysis_;
+    IGlobalAnalysis::TPtr GlobalAnalysis_;
+    INameService::TPtr Names_;
+    IRanking::TPtr Ranking_;
+};
+
+ISqlCompletionEngine::TPtr MakeSqlCompletionEngine(
+    TLexerSupplier lexer,
+    INameService::TPtr names,
+    TConfiguration configuration,
+    IRanking::TPtr ranking) {
+    return MakeHolder<TSqlCompletionEngine>(
+        lexer, std::move(names), std::move(ranking), std::move(configuration));
+}
+
 } // namespace NSQLComplete
 
 template <>