YQL-19747: Fix small TODOs

- YQL-19747: Remove unused header
- YQL-19747: Remove NameSet alias
- YQL-19747: Fix identifier typo
- YQL-19747: Cosmetics
- YQL-19747: Receive NameRequest as const ref
- YQL-19747: Remove string_util.h
- YQL-19747: Change engine.Complete
- YQL-19747: Remove configuration typedef
- YQL-19747: Rename context to local
commit_hash:451a6ba7c08e670a492222a29463be40a627c867

21 files changed, 163 insertions, 174 deletions

diff --git a/yql/essentials/sql/v1/complete/bench/main.cpp b/yql/essentials/sql/v1/complete/bench/main.cpp
index 4e9371e5f26..f9cb52ee11f 100644
--- a/yql/essentials/sql/v1/complete/bench/main.cpp
+++ b/yql/essentials/sql/v1/complete/bench/main.cpp
@@ -1,7 +1,7 @@
 #include <benchmark/benchmark.h>
 
 #include <yql/essentials/sql/v1/complete/name/service/static/name_service.h>
-#include <yql/essentials/sql/v1/complete/name/service/static/ranking.h>
+#include <yql/essentials/sql/v1/complete/name/service/ranking/ranking.h>
 #include <yql/essentials/sql/v1/complete/sql_complete.h>
 
 #include <yql/essentials/sql/v1/lexer/antlr4_pure/lexer.h>
diff --git a/yql/essentials/sql/v1/complete/bench/ya.make b/yql/essentials/sql/v1/complete/bench/ya.make
index 6edf991c73a..68f855aebd5 100644
--- a/yql/essentials/sql/v1/complete/bench/ya.make
+++ b/yql/essentials/sql/v1/complete/bench/ya.make
@@ -9,6 +9,7 @@ PEERDIR(
     yql/essentials/sql/v1/lexer/antlr4_pure
     yql/essentials/sql/v1/lexer/antlr4_pure_ansi
     yql/essentials/sql/v1/complete
+    yql/essentials/sql/v1/complete/name/service/ranking
     yql/essentials/sql/v1/complete/name/service/static
 )
 
diff --git a/yql/essentials/sql/v1/complete/check/check_complete.cpp b/yql/essentials/sql/v1/complete/check/check_complete.cpp
index e7adb846776..dbbc4b1e6c4 100644
--- a/yql/essentials/sql/v1/complete/check/check_complete.cpp
+++ b/yql/essentials/sql/v1/complete/check/check_complete.cpp
@@ -83,7 +83,7 @@ namespace NSQLComplete {
                 .CursorPosition = pos,
             };
 
-            auto output = engine->CompleteAsync(input).ExtractValueSync();
+            auto output = engine->Complete(input).ExtractValueSync();
             Y_DO_NOT_OPTIMIZE_AWAY(output);
 
             i += 1;
diff --git a/yql/essentials/sql/v1/complete/name/service/binding/name_service.cpp b/yql/essentials/sql/v1/complete/name/service/binding/name_service.cpp
index 52a0afccf8d..6d4e5d15318 100644
--- a/yql/essentials/sql/v1/complete/name/service/binding/name_service.cpp
+++ b/yql/essentials/sql/v1/complete/name/service/binding/name_service.cpp
@@ -13,7 +13,7 @@ namespace NSQLComplete {
             {
             }
 
-            NThreading::TFuture<TNameResponse> Lookup(TNameRequest request) const override {
+            NThreading::TFuture<TNameResponse> Lookup(const TNameRequest& request) const override {
                 if (request.Constraints.IsEmpty()) {
                     return NThreading::MakeFuture<TNameResponse>({});
                 }
@@ -39,7 +39,7 @@ namespace NSQLComplete {
 
             static TGenericName Transform(TStringBuf name) {
                 TBindingName unknown;
-                unknown.Indentifier = name;
+                unknown.Identifier = name;
                 return unknown;
             }
 
diff --git a/yql/essentials/sql/v1/complete/name/service/cluster/name_service.cpp b/yql/essentials/sql/v1/complete/name/service/cluster/name_service.cpp
index 6d4754b6d48..c65484627f0 100644
--- a/yql/essentials/sql/v1/complete/name/service/cluster/name_service.cpp
+++ b/yql/essentials/sql/v1/complete/name/service/cluster/name_service.cpp
@@ -37,7 +37,7 @@ namespace NSQLComplete {
 
                     for (auto& cluster : clusters) {
                         TClusterName name;
-                        name.Indentifier = std::move(cluster);
+                        name.Identifier = std::move(cluster);
                         response.RankedNames.emplace_back(std::move(name));
                     }
 
@@ -52,7 +52,7 @@ namespace NSQLComplete {
             {
             }
 
-            NThreading::TFuture<TNameResponse> Lookup(TNameRequest request) const override {
+            NThreading::TFuture<TNameResponse> Lookup(const TNameRequest& request) const override {
                 if (!request.Constraints.Cluster) {
                     return NThreading::MakeFuture<TNameResponse>({});
                 }
@@ -66,10 +66,10 @@ namespace NSQLComplete {
         private:
             static TString QualifiedClusterName(const TNameRequest& request) {
                 TClusterName cluster;
-                cluster.Indentifier = request.Prefix;
+                cluster.Identifier = request.Prefix;
 
                 TGenericName generic = request.Constraints.Qualified(cluster);
-                return std::get<TClusterName>(std::move(generic)).Indentifier;
+                return std::get<TClusterName>(std::move(generic)).Identifier;
             }
 
             IClusterDiscovery::TPtr Discovery_;
diff --git a/yql/essentials/sql/v1/complete/name/service/column/name_service.cpp b/yql/essentials/sql/v1/complete/name/service/column/name_service.cpp
index 97dfacc849a..ebc63d9d780 100644
--- a/yql/essentials/sql/v1/complete/name/service/column/name_service.cpp
+++ b/yql/essentials/sql/v1/complete/name/service/column/name_service.cpp
@@ -21,7 +21,7 @@ namespace NSQLComplete {
                 Schema_ = MakeSimpleSchema(MakeStaticSimpleSchema(std::move(data)));
             }
 
-            NThreading::TFuture<TNameResponse> Lookup(TNameRequest request) const override {
+            NThreading::TFuture<TNameResponse> Lookup(const TNameRequest& request) const override {
                 if (!request.Constraints.Column) {
                     return NThreading::MakeFuture<TNameResponse>({});
                 }
@@ -29,10 +29,15 @@ namespace NSQLComplete {
                 TNameResponse response;
 
                 for (const TString& tableName : Tables_) {
-                    THashSet<TString> without =
-                        request.Constraints.Column->WithoutByTableAlias[tableName];
-                    without.insert(request.Constraints.Column->WithoutByTableAlias[""].begin(),
-                                   request.Constraints.Column->WithoutByTableAlias[""].end());
+                    const auto& withoutByTableAlias = request.Constraints.Column->WithoutByTableAlias;
+
+                    THashSet<TString> without;
+                    if (auto it = withoutByTableAlias.find(tableName); it != withoutByTableAlias.end()) {
+                        without.insert(begin(it->second), end(it->second));
+                    }
+                    if (auto it = withoutByTableAlias.find(""); it != withoutByTableAlias.end()) {
+                        without.insert(begin(it->second), end(it->second));
+                    }
 
                     TDescribeTableRequest describeRequest = {
                         .TableCluster = "",
@@ -54,7 +59,7 @@ namespace NSQLComplete {
 
                         TColumnName name;
                         name.TableAlias = tableName;
-                        name.Indentifier = std::move(column);
+                        name.Identifier = std::move(column);
 
                         response.RankedNames.emplace_back(std::move(name));
                     }
diff --git a/yql/essentials/sql/v1/complete/name/service/impatient/name_service.cpp b/yql/essentials/sql/v1/complete/name/service/impatient/name_service.cpp
index 9d7dbe28307..11005b78f83 100644
--- a/yql/essentials/sql/v1/complete/name/service/impatient/name_service.cpp
+++ b/yql/essentials/sql/v1/complete/name/service/impatient/name_service.cpp
@@ -11,8 +11,8 @@ namespace NSQLComplete {
             {
             }
 
-            NThreading::TFuture<TNameResponse> Lookup(TNameRequest request) const override {
-                auto future = Origin_->Lookup(std::move(request));
+            NThreading::TFuture<TNameResponse> Lookup(const TNameRequest& request) const override {
+                auto future = Origin_->Lookup(request);
                 if (future.IsReady()) {
                     return future;
                 }
diff --git a/yql/essentials/sql/v1/complete/name/service/name_service.cpp b/yql/essentials/sql/v1/complete/name/service/name_service.cpp
index 529adce4dc1..b21177a3703 100644
--- a/yql/essentials/sql/v1/complete/name/service/name_service.cpp
+++ b/yql/essentials/sql/v1/complete/name/service/name_service.cpp
@@ -31,11 +31,11 @@ namespace NSQLComplete {
         return std::visit([&](auto&& name) -> TGenericName {
             using T = std::decay_t<decltype(name)>;
             if constexpr (std::is_same_v<T, TPragmaName>) {
-                SetPrefix(name.Indentifier, ".", *Pragma);
+                SetPrefix(name.Identifier, ".", *Pragma);
             } else if constexpr (std::is_same_v<T, TFunctionName>) {
-                SetPrefix(name.Indentifier, "::", *Function);
+                SetPrefix(name.Identifier, "::", *Function);
             } else if constexpr (std::is_same_v<T, TClusterName>) {
-                SetPrefix(name.Indentifier, ":", *Cluster);
+                SetPrefix(name.Identifier, ":", *Cluster);
             }
             return name;
         }, std::move(unqualified));
@@ -45,11 +45,11 @@ namespace NSQLComplete {
         return std::visit([&](auto&& name) -> TGenericName {
             using T = std::decay_t<decltype(name)>;
             if constexpr (std::is_same_v<T, TPragmaName>) {
-                FixPrefix(name.Indentifier, ".", *Pragma);
+                FixPrefix(name.Identifier, ".", *Pragma);
             } else if constexpr (std::is_same_v<T, TFunctionName>) {
-                FixPrefix(name.Indentifier, "::", *Function);
+                FixPrefix(name.Identifier, "::", *Function);
             } else if constexpr (std::is_same_v<T, TClusterName>) {
-                FixPrefix(name.Indentifier, ":", *Cluster);
+                FixPrefix(name.Identifier, ":", *Cluster);
             }
             return name;
         }, std::move(qualified));
diff --git a/yql/essentials/sql/v1/complete/name/service/name_service.h b/yql/essentials/sql/v1/complete/name/service/name_service.h
index aeb05e94a99..7b71c96919d 100644
--- a/yql/essentials/sql/v1/complete/name/service/name_service.h
+++ b/yql/essentials/sql/v1/complete/name/service/name_service.h
@@ -12,9 +12,8 @@
 
 namespace NSQLComplete {
 
-    // TODO(YQL-19747): Rename to Identifier
-    struct TIndentifier {
-        TString Indentifier;
+    struct TIdentifier {
+        TString Identifier;
     };
 
     struct TNamespaced {
@@ -25,11 +24,11 @@ namespace NSQLComplete {
         TString Content;
     };
 
-    struct TPragmaName: TIndentifier {
+    struct TPragmaName: TIdentifier {
         struct TConstraints: TNamespaced {};
     };
 
-    struct TTypeName: TIndentifier {
+    struct TTypeName: TIdentifier {
         struct TConstraints {};
 
         enum class EKind {
@@ -41,11 +40,11 @@ namespace NSQLComplete {
         EKind Kind = EKind::Simple;
     };
 
-    struct TFunctionName: TIndentifier {
+    struct TFunctionName: TIdentifier {
         struct TConstraints: TNamespaced {};
     };
 
-    struct THintName: TIndentifier {
+    struct THintName: TIdentifier {
         struct TConstraints {
             EStatementKind Statement;
         };
@@ -57,17 +56,17 @@ namespace NSQLComplete {
         THashSet<EObjectKind> Kinds;
     };
 
-    struct TFolderName: TIndentifier {
+    struct TFolderName: TIdentifier {
     };
 
-    struct TTableName: TIndentifier {
+    struct TTableName: TIdentifier {
     };
 
-    struct TClusterName: TIndentifier {
+    struct TClusterName: TIdentifier {
         struct TConstraints: TNamespaced {};
     };
 
-    struct TColumnName: TIndentifier {
+    struct TColumnName: TIdentifier {
         struct TConstraints {
             TVector<TAliased<TTableId>> Tables;
             THashMap<TString, THashSet<TString>> WithoutByTableAlias;
@@ -76,7 +75,7 @@ namespace NSQLComplete {
         TString TableAlias;
     };
 
-    struct TBindingName: TIndentifier {
+    struct TBindingName: TIdentifier {
     };
 
     struct TUnknownName {
@@ -146,8 +145,7 @@ namespace NSQLComplete {
     public:
         using TPtr = TIntrusivePtr<INameService>;
 
-        ~INameService() override = default; // TODO(YQL-19747): receive as const ref
-        virtual NThreading::TFuture<TNameResponse> Lookup(TNameRequest request) const = 0;
+        virtual NThreading::TFuture<TNameResponse> Lookup(const TNameRequest& request) const = 0;
     };
 
     TString NormalizeName(TStringBuf name);
diff --git a/yql/essentials/sql/v1/complete/name/service/ranking/ranking.cpp b/yql/essentials/sql/v1/complete/name/service/ranking/ranking.cpp
index 09edce52123..032b2a858f1 100644
--- a/yql/essentials/sql/v1/complete/name/service/ranking/ranking.cpp
+++ b/yql/essentials/sql/v1/complete/name/service/ranking/ranking.cpp
@@ -115,8 +115,8 @@ namespace NSQLComplete {
                 if constexpr (std::is_base_of_v<TKeyword, T>) {
                     return name.Content;
                 }
-                if constexpr (std::is_base_of_v<TIndentifier, T>) {
-                    return name.Indentifier;
+                if constexpr (std::is_base_of_v<TIdentifier, T>) {
+                    return name.Identifier;
                 }
                 if constexpr (std::is_base_of_v<TUnknownName, T>) {
                     return name.Content;
diff --git a/yql/essentials/sql/v1/complete/name/service/schema/name_service.cpp b/yql/essentials/sql/v1/complete/name/service/schema/name_service.cpp
index f230b2f00ea..8b663a44acc 100644
--- a/yql/essentials/sql/v1/complete/name/service/schema/name_service.cpp
+++ b/yql/essentials/sql/v1/complete/name/service/schema/name_service.cpp
@@ -14,7 +14,7 @@ namespace NSQLComplete {
             {
             }
 
-            NThreading::TFuture<TNameResponse> Lookup(TNameRequest request) const override {
+            NThreading::TFuture<TNameResponse> Lookup(const TNameRequest& request) const override {
                 if (request.Constraints.Object) {
                     return Schema_
                         ->List(ToListRequest(std::move(request)))
@@ -76,7 +76,7 @@ namespace NSQLComplete {
                                     }
 
                                     TColumnName name;
-                                    name.Indentifier = column;
+                                    name.Identifier = column;
                                     name.TableAlias = alias;
 
                                     response.RankedNames.emplace_back(std::move(name));
@@ -88,7 +88,7 @@ namespace NSQLComplete {
                     });
             }
 
-            static TListRequest ToListRequest(TNameRequest request) {
+            static TListRequest ToListRequest(const TNameRequest& request) {
                 return {
                     .Cluster = ClusterName(*request.Constraints.Object),
                     .Path = request.Prefix,
@@ -134,11 +134,11 @@ namespace NSQLComplete {
                 TGenericName name;
                 if (entry.Type == TFolderEntry::Folder) {
                     TFolderName local;
-                    local.Indentifier = std::move(entry.Name);
+                    local.Identifier = std::move(entry.Name);
                     name = std::move(local);
                 } else if (entry.Type == TFolderEntry::Table) {
                     TTableName local;
-                    local.Indentifier = std::move(entry.Name);
+                    local.Identifier = std::move(entry.Name);
                     name = std::move(local);
                 } else {
                     TUnknownName local;
diff --git a/yql/essentials/sql/v1/complete/name/service/static/name_service.cpp b/yql/essentials/sql/v1/complete/name/service/static/name_service.cpp
index ca3a66c2b0c..520452e13bc 100644
--- a/yql/essentials/sql/v1/complete/name/service/static/name_service.cpp
+++ b/yql/essentials/sql/v1/complete/name/service/static/name_service.cpp
@@ -26,7 +26,7 @@ namespace NSQLComplete {
             if constexpr (std::is_same_v<TKeyword, T>) {
                 content = &name.Content;
             } else {
-                content = &name.Indentifier;
+                content = &name.Identifier;
             }
 
             *content = element;
@@ -42,17 +42,17 @@ namespace NSQLComplete {
         const TNameConstraints& constraints,
         TVector<TGenericName>& out) {
         T name;
-        name.Indentifier = prefix;
+        name.Identifier = prefix;
         name = std::get<T>(constraints.Qualified(std::move(name)));
 
-        AppendAs<T>(out, FilteredByPrefix(name.Indentifier, index, NormalizeName));
+        AppendAs<T>(out, FilteredByPrefix(name.Identifier, index, NormalizeName));
         out = constraints.Unqualified(std::move(out));
     }
 
     class IRankingNameService: public INameService {
     private:
-        auto Ranking(TNameRequest request) const {
-            return [request = std::move(request), this](auto f) {
+        auto Ranking(const TNameRequest& request) const {
+            return [request, this](auto f) {
                 TNameResponse response = f.ExtractValue();
                 Ranking_->CropToSortedPrefix(
                     response.RankedNames,
@@ -68,11 +68,11 @@ namespace NSQLComplete {
         {
         }
 
-        NThreading::TFuture<TNameResponse> Lookup(TNameRequest request) const override {
+        NThreading::TFuture<TNameResponse> Lookup(const TNameRequest& request) const override {
             return LookupAllUnranked(request).Apply(Ranking(request));
         }
 
-        virtual NThreading::TFuture<TNameResponse> LookupAllUnranked(TNameRequest request) const = 0;
+        virtual NThreading::TFuture<TNameResponse> LookupAllUnranked(const TNameRequest& request) const = 0;
 
     private:
         IRanking::TPtr Ranking_;
@@ -85,12 +85,12 @@ namespace NSQLComplete {
         {
         }
 
-        NThreading::TFuture<TNameResponse> LookupAllUnranked(TNameRequest request) const override {
+        NThreading::TFuture<TNameResponse> LookupAllUnranked(const TNameRequest& request) const override {
+            TVector<TString> keywords = request.Keywords;
+
             TNameResponse response;
-            Sort(request.Keywords, NoCaseCompare);
-            AppendAs<TKeyword>(
-                response.RankedNames,
-                FilteredByPrefix(request.Prefix, request.Keywords));
+            Sort(keywords, NoCaseCompare);
+            AppendAs<TKeyword>(response.RankedNames, FilteredByPrefix(request.Prefix, keywords));
             return NThreading::MakeFuture<TNameResponse>(std::move(response));
         }
     };
@@ -103,7 +103,7 @@ namespace NSQLComplete {
         {
         }
 
-        NThreading::TFuture<TNameResponse> LookupAllUnranked(TNameRequest request) const override {
+        NThreading::TFuture<TNameResponse> LookupAllUnranked(const TNameRequest& request) const override {
             TNameResponse response;
             if (request.Constraints.Pragma) {
                 NameIndexScan<TPragmaName>(
@@ -147,7 +147,7 @@ namespace NSQLComplete {
         {
         }
 
-        NThreading::TFuture<TNameResponse> LookupAllUnranked(TNameRequest request) const override {
+        NThreading::TFuture<TNameResponse> LookupAllUnranked(const TNameRequest& request) const override {
             TNameResponse response;
             if (request.Constraints.Type) {
                 NameIndexScan<TTypeName>(SimpleTypes_, request.Prefix, request.Constraints, response.RankedNames);
@@ -181,7 +181,7 @@ namespace NSQLComplete {
         {
         }
 
-        NThreading::TFuture<TNameResponse> LookupAllUnranked(TNameRequest request) const override {
+        NThreading::TFuture<TNameResponse> LookupAllUnranked(const TNameRequest& request) const override {
             TNameResponse response;
             if (request.Constraints.Function) {
                 NameIndexScan<TFunctionName>(
@@ -213,7 +213,7 @@ namespace NSQLComplete {
         {
         }
 
-        NThreading::TFuture<TNameResponse> LookupAllUnranked(TNameRequest request) const override {
+        NThreading::TFuture<TNameResponse> LookupAllUnranked(const TNameRequest& request) const override {
             TNameResponse response;
             if (request.Constraints.Hint) {
                 const auto stmt = request.Constraints.Hint->Statement;
diff --git a/yql/essentials/sql/v1/complete/name/service/static/name_set.h b/yql/essentials/sql/v1/complete/name/service/static/name_set.h
index 2e723e65a72..d3b6e72fc2c 100644
--- a/yql/essentials/sql/v1/complete/name/service/static/name_set.h
+++ b/yql/essentials/sql/v1/complete/name/service/static/name_set.h
@@ -16,9 +16,6 @@ namespace NSQLComplete {
         THashMap<EStatementKind, TVector<TString>> Hints;
     };
 
-    // TODO(YQL-19747): Mirate YDB CLI to TNameSet
-    using NameSet = TNameSet;
-
     TNameSet Pruned(TNameSet names, const TFrequencyData& frequency);
 
     TNameSet LoadDefaultNameSet();
diff --git a/yql/essentials/sql/v1/complete/name/service/static/ranking.h b/yql/essentials/sql/v1/complete/name/service/static/ranking.h
deleted file mode 100644
index 947f33065cd..00000000000
--- a/yql/essentials/sql/v1/complete/name/service/static/ranking.h
+++ /dev/null
@@ -1,4 +0,0 @@
-#pragma once
-
-// TODO(YQL-19747): Migrate YDB CLI
-#include <yql/essentials/sql/v1/complete/name/service/ranking/ranking.h>
diff --git a/yql/essentials/sql/v1/complete/name/service/union/name_service.cpp b/yql/essentials/sql/v1/complete/name/service/union/name_service.cpp
index 67171882703..f96f5856a6a 100644
--- a/yql/essentials/sql/v1/complete/name/service/union/name_service.cpp
+++ b/yql/essentials/sql/v1/complete/name/service/union/name_service.cpp
@@ -16,14 +16,14 @@ namespace NSQLComplete {
             {
             }
 
-            NThreading::TFuture<TNameResponse> Lookup(TNameRequest request) const override {
+            NThreading::TFuture<TNameResponse> Lookup(const TNameRequest& request) const override {
                 TVector<NThreading::TFuture<TNameResponse>> fs;
                 for (const auto& c : Children_) {
                     fs.emplace_back(c->Lookup(request));
                 }
 
                 return NThreading::WaitAll(fs)
-                    .Apply([fs, ranking = Ranking_, request = std::move(request)](auto) {
+                    .Apply([fs, ranking = Ranking_, request](auto) {
                         return Union(fs, ranking, request.Constraints, request.Limit);
                     });
             }
diff --git a/yql/essentials/sql/v1/complete/name_mapping.cpp b/yql/essentials/sql/v1/complete/name_mapping.cpp
index e8e317e0b57..071ba1d4d3e 100644
--- a/yql/essentials/sql/v1/complete/name_mapping.cpp
+++ b/yql/essentials/sql/v1/complete/name_mapping.cpp
@@ -6,16 +6,16 @@ namespace NSQLComplete {
 
     namespace {
 
-        TString ToIdentifier(TString content, const TLocalSyntaxContext& context) {
-            if (IsPlain(content) && !context.IsQuoted.AtLhs && !context.IsQuoted.AtRhs) {
+        TString ToIdentifier(TString content, const TLocalSyntaxContext& local) {
+            if (IsPlain(content) && !local.IsQuoted.AtLhs && !local.IsQuoted.AtRhs) {
                 return content;
             }
 
             SubstGlobal(content, "`", "``");
-            if (!context.IsQuoted.AtLhs) {
+            if (!local.IsQuoted.AtLhs) {
                 content.prepend('`');
             }
-            if (!context.IsQuoted.AtRhs) {
+            if (!local.IsQuoted.AtRhs) {
                 content.append('`');
             }
             return content;
@@ -23,8 +23,8 @@ namespace NSQLComplete {
 
     } // namespace
 
-    TCandidate ToCandidate(TKeyword name, TLocalSyntaxContext& context) {
-        TVector<TString>& seq = context.Keywords[name.Content];
+    TCandidate ToCandidate(TKeyword name, TLocalSyntaxContext& local) {
+        TVector<TString>& seq = local.Keywords[name.Content];
         seq.insert(std::begin(seq), name.Content);
 
         TCandidate candidate = {
@@ -41,13 +41,13 @@ namespace NSQLComplete {
     }
 
     TCandidate ToCandidate(TPragmaName name) {
-        return {ECandidateKind::PragmaName, std::move(name.Indentifier)};
+        return {ECandidateKind::PragmaName, std::move(name.Identifier)};
     }
 
     TCandidate ToCandidate(TTypeName name) {
         TCandidate candidate = {
             .Kind = ECandidateKind::TypeName,
-            .Content = std::move(name.Indentifier),
+            .Content = std::move(name.Identifier),
         };
 
         switch (name.Kind) {
@@ -69,7 +69,7 @@ namespace NSQLComplete {
     TCandidate ToCandidate(TFunctionName name) {
         TCandidate candidate = {
             .Kind = ECandidateKind::FunctionName,
-            .Content = std::move(name.Indentifier),
+            .Content = std::move(name.Identifier),
         };
 
         candidate.Content += "()";
@@ -79,22 +79,22 @@ namespace NSQLComplete {
     }
 
     TCandidate ToCandidate(THintName name) {
-        return {ECandidateKind::HintName, std::move(name.Indentifier)};
+        return {ECandidateKind::HintName, std::move(name.Identifier)};
     }
 
-    TCandidate ToCandidate(TFolderName name, TLocalSyntaxContext& context) {
+    TCandidate ToCandidate(TFolderName name, TLocalSyntaxContext& local) {
         TCandidate candidate = {
             .Kind = ECandidateKind::FolderName,
-            .Content = std::move(name.Indentifier),
+            .Content = std::move(name.Identifier),
         };
 
-        if (!context.IsQuoted.AtLhs) {
+        if (!local.IsQuoted.AtLhs) {
             candidate.Content.prepend('`');
         }
 
         candidate.Content.append('/');
 
-        if (!context.IsQuoted.AtRhs) {
+        if (!local.IsQuoted.AtRhs) {
             candidate.Content.append('`');
             candidate.CursorShift = 1;
         }
@@ -102,45 +102,45 @@ namespace NSQLComplete {
         return candidate;
     }
 
-    TCandidate ToCandidate(TTableName name, TLocalSyntaxContext& context) {
-        if (!context.IsQuoted.AtLhs) {
-            name.Indentifier.prepend('`');
+    TCandidate ToCandidate(TTableName name, TLocalSyntaxContext& local) {
+        if (!local.IsQuoted.AtLhs) {
+            name.Identifier.prepend('`');
         }
-        if (!context.IsQuoted.AtRhs) {
-            name.Indentifier.append('`');
+        if (!local.IsQuoted.AtRhs) {
+            name.Identifier.append('`');
         }
-        return {ECandidateKind::TableName, std::move(name.Indentifier)};
+        return {ECandidateKind::TableName, std::move(name.Identifier)};
     }
 
     TCandidate ToCandidate(TClusterName name) {
-        return {ECandidateKind::ClusterName, std::move(name.Indentifier)};
+        return {ECandidateKind::ClusterName, std::move(name.Identifier)};
     }
 
-    TCandidate ToCandidate(TColumnName name, TLocalSyntaxContext& context) {
-        name.Indentifier = ToIdentifier(std::move(name.Indentifier), context);
+    TCandidate ToCandidate(TColumnName name, TLocalSyntaxContext& local) {
+        name.Identifier = ToIdentifier(std::move(name.Identifier), local);
 
-        if (context.Column->Table.empty() && !name.TableAlias.empty()) {
-            name.Indentifier.prepend('.');
-            name.Indentifier.prepend(name.TableAlias);
+        if (local.Column->Table.empty() && !name.TableAlias.empty()) {
+            name.Identifier.prepend('.');
+            name.Identifier.prepend(name.TableAlias);
         }
 
-        return {ECandidateKind::ColumnName, std::move(name.Indentifier)};
+        return {ECandidateKind::ColumnName, std::move(name.Identifier)};
     }
 
-    TCandidate ToCandidate(TBindingName name, TLocalSyntaxContext& context) {
-        if (!context.Binding) {
-            name.Indentifier.prepend('$');
+    TCandidate ToCandidate(TBindingName name, TLocalSyntaxContext& local) {
+        if (!local.Binding) {
+            name.Identifier.prepend('$');
         }
-        return {ECandidateKind::BindingName, std::move(name.Indentifier)};
+        return {ECandidateKind::BindingName, std::move(name.Identifier)};
     }
 
-    TCandidate ToCandidate(TUnknownName name, TLocalSyntaxContext& context) {
-        name.Content = ToIdentifier(std::move(name.Content), context);
+    TCandidate ToCandidate(TUnknownName name, TLocalSyntaxContext& local) {
+        name.Content = ToIdentifier(std::move(name.Content), local);
 
         return {ECandidateKind::UnknownName, std::move(name.Content)};
     }
 
-    TCandidate ToCandidate(TGenericName generic, TLocalSyntaxContext& context) {
+    TCandidate ToCandidate(TGenericName generic, TLocalSyntaxContext& local) {
         return std::visit([&](auto&& name) -> TCandidate {
             using T = std::decay_t<decltype(name)>;
             constexpr bool IsContextSensitive =
@@ -152,18 +152,18 @@ namespace NSQLComplete {
                 std::is_same_v<T, TUnknownName>;
 
             if constexpr (IsContextSensitive) {
-                return ToCandidate(std::move(name), context);
+                return ToCandidate(std::move(name), local);
             } else {
                 return ToCandidate(std::move(name));
             }
         }, std::move(generic));
     }
 
-    TVector<TCandidate> ToCandidate(TVector<TGenericName> names, TLocalSyntaxContext context) {
+    TVector<TCandidate> ToCandidate(TVector<TGenericName> names, TLocalSyntaxContext local) {
         TVector<TCandidate> candidates;
         candidates.reserve(names.size());
         for (auto& name : names) {
-            candidates.emplace_back(ToCandidate(std::move(name), context));
+            candidates.emplace_back(ToCandidate(std::move(name), local));
         }
         return candidates;
     }
diff --git a/yql/essentials/sql/v1/complete/name_mapping.h b/yql/essentials/sql/v1/complete/name_mapping.h
index 0bde9ffd6dc..2afa509de01 100644
--- a/yql/essentials/sql/v1/complete/name_mapping.h
+++ b/yql/essentials/sql/v1/complete/name_mapping.h
@@ -7,8 +7,8 @@
 
 namespace NSQLComplete {
 
-    TCandidate ToCandidate(TGenericName name, TLocalSyntaxContext& context);
+    TCandidate ToCandidate(TGenericName name, TLocalSyntaxContext& local);
 
-    TVector<TCandidate> ToCandidate(TVector<TGenericName> names, TLocalSyntaxContext context);
+    TVector<TCandidate> ToCandidate(TVector<TGenericName> names, TLocalSyntaxContext local);
 
 } // namespace NSQLComplete
diff --git a/yql/essentials/sql/v1/complete/sql_complete.cpp b/yql/essentials/sql/v1/complete/sql_complete.cpp
index fa84e749a8c..435bf705e49 100644
--- a/yql/essentials/sql/v1/complete/sql_complete.cpp
+++ b/yql/essentials/sql/v1/complete/sql_complete.cpp
@@ -45,9 +45,9 @@ namespace NSQLComplete {
         {
         }
 
-        TCompletion
+        NThreading::TFuture<TCompletion>
         Complete(TCompletionInput input, TEnvironment env = {}) override {
-            return CompleteAsync(input, env).ExtractValueSync();
+            return CompleteAsync(input, env);
         }
 
         NThreading::TFuture<TCompletion> CompleteAsync(TCompletionInput input, TEnvironment env) override {
@@ -59,15 +59,14 @@ namespace NSQLComplete {
                     << " for input size " << input.Text.size();
             }
 
-            TLocalSyntaxContext context = SyntaxAnalysis_->Analyze(input);
-            auto keywords = context.Keywords;
+            TLocalSyntaxContext local = SyntaxAnalysis_->Analyze(input);
 
             TGlobalContext global = GlobalAnalysis_->Analyze(input, std::move(env));
 
-            TNameRequest request = NameRequestFrom(input, context, global);
+            TNameRequest request = NameRequestFrom(input, local, global);
             if (request.IsEmpty()) {
                 return NThreading::MakeFuture<TCompletion>({
-                    .CompletedToken = GetCompletedToken(input, context.EditRange),
+                    .CompletedToken = GetCompletedToken(input, local.EditRange),
                     .Candidates = {},
                 });
             }
@@ -76,18 +75,18 @@ namespace NSQLComplete {
 
             children.emplace_back(MakeBindingNameService(std::move(global.Names)));
 
-            if (!context.Binding && global.Column) {
+            if (!local.Binding && global.Column) {
                 children.emplace_back(MakeColumnNameService(std::move(global.Column->Columns)));
             }
 
-            if (!context.Binding) {
+            if (!local.Binding) {
                 children.emplace_back(Names_);
             }
 
             return MakeUnionNameService(std::move(children), MakeDummyRanking())
                 ->Lookup(std::move(request))
-                .Apply([this, input, context = std::move(context)](auto f) {
-                    return ToCompletion(input, std::move(context), f.ExtractValue());
+                .Apply([this, input, local = std::move(local)](auto f) {
+                    return ToCompletion(input, std::move(local), f.ExtractValue());
                 });
         }
 
@@ -101,56 +100,56 @@ namespace NSQLComplete {
 
         TNameRequest NameRequestFrom(
             TCompletionInput input,
-            const TLocalSyntaxContext& context, // TODO(YQL-19747): rename to `local`
+            const TLocalSyntaxContext& local,
             const TGlobalContext& global) const {
             TNameRequest request = {
-                .Prefix = TString(GetCompletedToken(input, context.EditRange).Content),
+                .Prefix = TString(GetCompletedToken(input, local.EditRange).Content),
                 .Limit = Configuration_.Limit,
             };
 
-            for (const auto& [first, _] : context.Keywords) {
+            for (const auto& [first, _] : local.Keywords) {
                 request.Keywords.emplace_back(first);
             }
 
-            if (context.Pragma) {
+            if (local.Pragma) {
                 TPragmaName::TConstraints constraints;
-                constraints.Namespace = context.Pragma->Namespace;
+                constraints.Namespace = local.Pragma->Namespace;
                 request.Constraints.Pragma = std::move(constraints);
             }
 
-            if (context.Type) {
+            if (local.Type) {
                 request.Constraints.Type = TTypeName::TConstraints();
             }
 
-            if (context.Function) {
+            if (local.Function) {
                 TFunctionName::TConstraints constraints;
-                constraints.Namespace = context.Function->Namespace;
+                constraints.Namespace = local.Function->Namespace;
                 request.Constraints.Function = std::move(constraints);
             }
 
-            if (context.Hint) {
+            if (local.Hint) {
                 THintName::TConstraints constraints;
-                constraints.Statement = context.Hint->StatementKind;
+                constraints.Statement = local.Hint->StatementKind;
                 request.Constraints.Hint = std::move(constraints);
             }
 
-            if (context.Object) {
+            if (local.Object) {
                 request.Constraints.Object = TObjectNameConstraints();
-                request.Constraints.Object->Kinds = context.Object->Kinds;
-                request.Prefix = context.Object->Path;
+                request.Constraints.Object->Kinds = local.Object->Kinds;
+                request.Prefix = local.Object->Path;
             }
 
-            if (context.Object && global.Use) {
+            if (local.Object && global.Use) {
                 request.Constraints.Object->Provider = global.Use->Provider;
                 request.Constraints.Object->Cluster = global.Use->Cluster;
             }
 
-            if (context.Object && context.Object->HasCluster()) {
-                request.Constraints.Object->Provider = context.Object->Provider;
-                request.Constraints.Object->Cluster = context.Object->Cluster;
+            if (local.Object && local.Object->HasCluster()) {
+                request.Constraints.Object->Provider = local.Object->Provider;
+                request.Constraints.Object->Cluster = local.Object->Cluster;
             }
 
-            if (context.Cluster) {
+            if (local.Cluster) {
                 TClusterName::TConstraints constraints;
                 constraints.Namespace = ""; // TODO(YQL-19747): filter by provider
                 request.Constraints.Cluster = std::move(constraints);
@@ -164,8 +163,8 @@ namespace NSQLComplete {
                 object->Kinds.emplace(EObjectKind::Table);
             }
 
-            if (context.Column && global.Column) {
-                TMaybe<TStringBuf> table = context.Column->Table;
+            if (local.Column && global.Column) {
+                TMaybe<TStringBuf> table = local.Column->Table;
                 table = !table->empty() ? table : Nothing();
 
                 request.Constraints.Column = TColumnName::TConstraints();
@@ -177,10 +176,10 @@ namespace NSQLComplete {
             return request;
         }
 
-        TCompletion ToCompletion(TCompletionInput input, TLocalSyntaxContext context, TNameResponse response) const {
+        TCompletion ToCompletion(TCompletionInput input, TLocalSyntaxContext local, TNameResponse response) const {
             TCompletion completion = {
-                .CompletedToken = GetCompletedToken(input, context.EditRange),
-                .Candidates = ToCandidate(std::move(response.RankedNames), std::move(context)),
+                .CompletedToken = GetCompletedToken(input, local.EditRange),
+                .Candidates = ToCandidate(std::move(response.RankedNames), std::move(local)),
             };
 
             if (response.NameHintLength) {
diff --git a/yql/essentials/sql/v1/complete/sql_complete.h b/yql/essentials/sql/v1/complete/sql_complete.h
index 41fb67fc090..3878560a90b 100644
--- a/yql/essentials/sql/v1/complete/sql_complete.h
+++ b/yql/essentials/sql/v1/complete/sql_complete.h
@@ -55,12 +55,9 @@ namespace NSQLComplete {
     public:
         using TPtr = THolder<ISqlCompletionEngine>;
 
-        // TODO(YQL-19747): Deprecated, Migrate YDB CLI to `TConfiguration`
-        using TConfiguration = NSQLComplete::TConfiguration;
-
         virtual ~ISqlCompletionEngine() = default;
 
-        virtual TCompletion
+        virtual NThreading::TFuture<TCompletion>
         Complete(TCompletionInput input, TEnvironment env = {}) = 0;
 
         virtual NThreading::TFuture<TCompletion> // TODO(YQL-19747): Migrate YDB CLI to `Complete` method
diff --git a/yql/essentials/sql/v1/complete/sql_complete_ut.cpp b/yql/essentials/sql/v1/complete/sql_complete_ut.cpp
index d5e7e3ac55b..8c1ffba06f4 100644
--- a/yql/essentials/sql/v1/complete/sql_complete_ut.cpp
+++ b/yql/essentials/sql/v1/complete/sql_complete_ut.cpp
@@ -38,7 +38,7 @@ public:
 
 class TFailingNameService: public INameService {
 public:
-    NThreading::TFuture<TNameResponse> Lookup(TNameRequest) const override {
+    NThreading::TFuture<TNameResponse> Lookup(const TNameRequest&) const override {
         auto e = std::make_exception_ptr(TDummyException());
         return NThreading::MakeErrorFuture<TNameResponse>(e);
     }
@@ -154,7 +154,7 @@ Y_UNIT_TEST_SUITE(SqlCompleteTests) {
     }
 
     TVector<TCandidate> Complete(ISqlCompletionEngine::TPtr& engine, TString sharped, TEnvironment env = {}) {
-        return engine->CompleteAsync(SharpedInput(sharped), std::move(env)).GetValueSync().Candidates;
+        return engine->Complete(SharpedInput(sharped), std::move(env)).GetValueSync().Candidates;
     }
 
     TVector<TCandidate> CompleteTop(size_t limit, ISqlCompletionEngine::TPtr& engine, TString sharped) {
@@ -453,35 +453,35 @@ Y_UNIT_TEST_SUITE(SqlCompleteTests) {
                 {PragmaName, "yson.CastToString"},
                 {PragmaName, "yt.RuntimeCluster"},
                 {PragmaName, "yt.RuntimeClusterSelection"}};
-            auto completion = engine->CompleteAsync({"PRAGMA "}).GetValueSync();
+            auto completion = engine->Complete({"PRAGMA "}).GetValueSync();
             UNIT_ASSERT_VALUES_EQUAL(completion.Candidates, expected);
             UNIT_ASSERT_VALUES_EQUAL(completion.CompletedToken.Content, "");
         }
         {
             TVector<TCandidate> expected = {
                 {PragmaName, "yson.CastToString"}};
-            auto completion = engine->CompleteAsync({"PRAGMA ys"}).GetValueSync();
+            auto completion = engine->Complete({"PRAGMA ys"}).GetValueSync();
             UNIT_ASSERT_VALUES_EQUAL(completion.Candidates, expected);
             UNIT_ASSERT_VALUES_EQUAL(completion.CompletedToken.Content, "ys");
         }
         {
             TVector<TCandidate> expected = {
                 {PragmaName, "yson.CastToString"}};
-            auto completion = engine->CompleteAsync({"PRAGMA yson"}).GetValueSync();
+            auto completion = engine->Complete({"PRAGMA yson"}).GetValueSync();
             UNIT_ASSERT_VALUES_EQUAL(completion.Candidates, expected);
             UNIT_ASSERT_VALUES_EQUAL(completion.CompletedToken.Content, "yson");
         }
         {
             TVector<TCandidate> expected = {
                 {PragmaName, "CastToString"}};
-            auto completion = engine->CompleteAsync({"PRAGMA yson."}).GetValueSync();
+            auto completion = engine->Complete({"PRAGMA yson."}).GetValueSync();
             UNIT_ASSERT_VALUES_EQUAL(completion.Candidates, expected);
             UNIT_ASSERT_VALUES_EQUAL(completion.CompletedToken.Content, "");
         }
         {
             TVector<TCandidate> expected = {
                 {PragmaName, "CastToString"}};
-            auto completion = engine->CompleteAsync({"PRAGMA yson.cast"}).GetValueSync();
+            auto completion = engine->Complete({"PRAGMA yson.cast"}).GetValueSync();
             UNIT_ASSERT_VALUES_EQUAL(completion.Candidates, expected);
             UNIT_ASSERT_VALUES_EQUAL(completion.CompletedToken.Content, "cast");
         }
@@ -568,7 +568,7 @@ Y_UNIT_TEST_SUITE(SqlCompleteTests) {
             TVector<TCandidate> expected = {
                 {FolderName, "`prod/`", 1},
             };
-            TCompletion actual = engine->Complete(SharpedInput(input));
+            TCompletion actual = engine->Complete(SharpedInput(input)).ExtractValueSync();
             UNIT_ASSERT_VALUES_EQUAL(actual.Candidates, expected);
             UNIT_ASSERT_VALUES_EQUAL(actual.CompletedToken.Content, "pr");
         }
@@ -589,7 +589,7 @@ Y_UNIT_TEST_SUITE(SqlCompleteTests) {
                 {FolderName, "prod/"},
                 {FolderName, "test/"},
             };
-            TCompletion actual = engine->Complete(SharpedInput(input));
+            TCompletion actual = engine->Complete(SharpedInput(input)).ExtractValueSync();
             UNIT_ASSERT_VALUES_EQUAL(actual.Candidates, expected);
             UNIT_ASSERT_VALUES_EQUAL(actual.CompletedToken.Content, "");
         }
@@ -600,7 +600,7 @@ Y_UNIT_TEST_SUITE(SqlCompleteTests) {
                 {TableName, "account"},
                 {TableName, "example"},
             };
-            TCompletion actual = engine->Complete(SharpedInput(input));
+            TCompletion actual = engine->Complete(SharpedInput(input)).ExtractValueSync();
             UNIT_ASSERT_VALUES_EQUAL(actual.Candidates, expected);
             UNIT_ASSERT_VALUES_EQUAL(actual.CompletedToken.Content, "");
         }
@@ -610,7 +610,7 @@ Y_UNIT_TEST_SUITE(SqlCompleteTests) {
                 {TableName, "abacaba"},
                 {TableName, "account"},
             };
-            TCompletion actual = engine->Complete(SharpedInput(input));
+            TCompletion actual = engine->Complete(SharpedInput(input)).ExtractValueSync();
             UNIT_ASSERT_VALUES_EQUAL(actual.Candidates, expected);
             UNIT_ASSERT_VALUES_EQUAL(actual.CompletedToken.Content, "a");
         }
@@ -619,7 +619,7 @@ Y_UNIT_TEST_SUITE(SqlCompleteTests) {
             TVector<TCandidate> expected = {
                 {FolderName, ".sys/"},
             };
-            TCompletion actual = engine->Complete(SharpedInput(input));
+            TCompletion actual = engine->Complete(SharpedInput(input)).ExtractValueSync();
             UNIT_ASSERT_VALUES_EQUAL(actual.Candidates, expected);
             UNIT_ASSERT_VALUES_EQUAL(actual.CompletedToken.Content, ".sy");
         }
@@ -628,7 +628,7 @@ Y_UNIT_TEST_SUITE(SqlCompleteTests) {
             TVector<TCandidate> expected = {
                 {FolderName, "service/"},
             };
-            TCompletion actual = engine->Complete(SharpedInput(input));
+            TCompletion actual = engine->Complete(SharpedInput(input)).ExtractValueSync();
             UNIT_ASSERT_VALUES_EQUAL(actual.Candidates, expected);
             UNIT_ASSERT_VALUES_EQUAL(actual.CompletedToken.Content, "ser");
         }
@@ -875,7 +875,7 @@ Y_UNIT_TEST_SUITE(SqlCompleteTests) {
             TVector<TCandidate> expected = {
                 {FunctionName, "DateTime::Split()", 1},
             };
-            auto completion = engine->CompleteAsync({"SELECT Date"}).GetValueSync();
+            auto completion = engine->Complete({"SELECT Date"}).GetValueSync();
             UNIT_ASSERT_VALUES_EQUAL(completion.Candidates, expected);
             UNIT_ASSERT_VALUES_EQUAL(completion.CompletedToken.Content, "Date");
         }
@@ -883,14 +883,14 @@ Y_UNIT_TEST_SUITE(SqlCompleteTests) {
             TVector<TCandidate> expected = {
                 {FunctionName, "Split()", 1},
             };
-            auto completion = engine->CompleteAsync({"SELECT DateTime:"}).GetValueSync();
+            auto completion = engine->Complete({"SELECT DateTime:"}).GetValueSync();
             UNIT_ASSERT(completion.Candidates.empty());
         }
         {
             TVector<TCandidate> expected = {
                 {FunctionName, "Split()", 1},
             };
-            auto completion = engine->CompleteAsync({"SELECT DateTime::"}).GetValueSync();
+            auto completion = engine->Complete({"SELECT DateTime::"}).GetValueSync();
             UNIT_ASSERT_VALUES_EQUAL(completion.Candidates, expected);
             UNIT_ASSERT_VALUES_EQUAL(completion.CompletedToken.Content, "");
         }
@@ -898,7 +898,7 @@ Y_UNIT_TEST_SUITE(SqlCompleteTests) {
             TVector<TCandidate> expected = {
                 {FunctionName, "Split()", 1},
             };
-            auto completion = engine->CompleteAsync({"SELECT DateTime::s"}).GetValueSync();
+            auto completion = engine->Complete({"SELECT DateTime::s"}).GetValueSync();
             UNIT_ASSERT_VALUES_EQUAL(completion.Candidates, expected);
             UNIT_ASSERT_VALUES_EQUAL(completion.CompletedToken.Content, "s");
         }
@@ -1334,7 +1334,7 @@ Y_UNIT_TEST_SUITE(SqlCompleteTests) {
 
         for (std::size_t size = 0; size <= queryUtf16.size(); ++size) {
             const TWtringBuf prefixUtf16(queryUtf16, 0, size);
-            TCompletion completion = engine->CompleteAsync({TString::FromUtf16(prefixUtf16)}).GetValueSync();
+            TCompletion completion = engine->Complete({TString::FromUtf16(prefixUtf16)}).GetValueSync();
             Y_DO_NOT_OPTIMIZE_AWAY(completion);
         }
     }
@@ -1367,7 +1367,7 @@ JOIN yt:$cluster_name.test;
                 .Text = query,
                 .CursorPosition = static_cast<size_t>(std::distance(begin, ptr)),
             };
-            TCompletion completion = engine->CompleteAsync(input).GetValueSync();
+            TCompletion completion = engine->Complete(input).GetValueSync();
             Y_DO_NOT_OPTIMIZE_AWAY(completion);
         }
     }
@@ -1399,15 +1399,15 @@ JOIN yt:$cluster_name.test;
     Y_UNIT_TEST(InvalidCursorPosition) {
         auto engine = MakeSqlCompletionEngineUT();
 
-        UNIT_ASSERT_NO_EXCEPTION(engine->CompleteAsync({"", 0}).GetValueSync());
-        UNIT_ASSERT_EXCEPTION(engine->CompleteAsync({"", 1}).GetValueSync(), yexception);
+        UNIT_ASSERT_NO_EXCEPTION(engine->Complete({"", 0}).GetValueSync());
+        UNIT_ASSERT_EXCEPTION(engine->Complete({"", 1}).GetValueSync(), yexception);
 
-        UNIT_ASSERT_NO_EXCEPTION(engine->CompleteAsync({"s", 0}).GetValueSync());
-        UNIT_ASSERT_NO_EXCEPTION(engine->CompleteAsync({"s", 1}).GetValueSync());
+        UNIT_ASSERT_NO_EXCEPTION(engine->Complete({"s", 0}).GetValueSync());
+        UNIT_ASSERT_NO_EXCEPTION(engine->Complete({"s", 1}).GetValueSync());
 
-        UNIT_ASSERT_NO_EXCEPTION(engine->CompleteAsync({"ы", 0}).GetValueSync());
-        UNIT_ASSERT_EXCEPTION(engine->CompleteAsync({"ы", 1}).GetValueSync(), yexception);
-        UNIT_ASSERT_NO_EXCEPTION(engine->CompleteAsync({"ы", 2}).GetValueSync());
+        UNIT_ASSERT_NO_EXCEPTION(engine->Complete({"ы", 0}).GetValueSync());
+        UNIT_ASSERT_EXCEPTION(engine->Complete({"ы", 1}).GetValueSync(), yexception);
+        UNIT_ASSERT_NO_EXCEPTION(engine->Complete({"ы", 2}).GetValueSync());
     }
 
     Y_UNIT_TEST(DefaultNameService) {
diff --git a/yql/essentials/sql/v1/complete/string_util.h b/yql/essentials/sql/v1/complete/string_util.h
deleted file mode 100644
index f0691764601..00000000000
--- a/yql/essentials/sql/v1/complete/string_util.h
+++ /dev/null
@@ -1,4 +0,0 @@
-#pragma once
-
-// TODO(YQL-19747): Migrate YDB CLI to yql/essentials/sql/v1/complete/text/word.h
-#include <yql/essentials/sql/v1/complete/text/word.h>