Introduced SQL ITranslator

commit_hash:f58b2fb436f14fc4a11ce2e315f10d71e6d1ec77

14 files changed, 329 insertions, 34 deletions

diff --git a/yql/essentials/parser/pg_wrapper/interface/parser.h b/yql/essentials/parser/pg_wrapper/interface/parser.h
index f86fee1630..db82da2298 100644
--- a/yql/essentials/parser/pg_wrapper/interface/parser.h
+++ b/yql/essentials/parser/pg_wrapper/interface/parser.h
@@ -6,6 +6,8 @@
 namespace NSQLTranslation {
 
 struct TTranslationSettings;
+class ITranslator;
+using TTranslatorPtr = TIntrusivePtr<ITranslator>;
 
 } // NSQLTranslation
 
@@ -16,5 +18,6 @@ TVector<NYql::TAstParseResult> PGToYqlStatements(const TString& query, const NSQ
 std::unique_ptr<NYql::NPg::IExtensionSqlParser> CreateExtensionSqlParser();
 std::unique_ptr<NYql::NPg::ISystemFunctionsParser> CreateSystemFunctionsParser();
 std::unique_ptr<NYql::NPg::ISqlLanguageParser> CreateSqlLanguageParser();
+NSQLTranslation::TTranslatorPtr MakeTranslator();
 
 } // NSQLTranslationPG
diff --git a/yql/essentials/sql/pg/pg_sql.cpp b/yql/essentials/sql/pg/pg_sql.cpp
index 84d3c39454..1843ea4f9e 100644
--- a/yql/essentials/sql/pg/pg_sql.cpp
+++ b/yql/essentials/sql/pg/pg_sql.cpp
@@ -29,6 +29,7 @@ extern "C" {
 #include "utils.h"
 #include <yql/essentials/ast/yql_expr.h>
 #include <yql/essentials/sql/settings/partitioning.h>
+#include <yql/essentials/sql/settings/translator.h>
 #include <yql/essentials/parser/pg_wrapper/interface/config.h>
 #include <yql/essentials/parser/pg_wrapper/interface/parser.h>
 #include <yql/essentials/parser/pg_wrapper/interface/utils.h>
@@ -1665,7 +1666,7 @@ public:
         const auto select = ParseSelectStmt(
             &selectStmt,
             {
-                .Inner = true, 
+                .Inner = true,
                 .AllowEmptyResSet = true,
                 .EmitPgStar = true,
                 .FillTargetColumns = false,
@@ -2971,7 +2972,7 @@ public:
         return State.Statements.back();
     }
 
-    [[nodiscard]] 
+    [[nodiscard]]
     TAstNode* ParseAlterTableStmt(const AlterTableStmt* value) {
         std::vector<TAstNode*> options;
         TString mode = (value->missing_ok) ? "alter_if_exists" : "alter";
@@ -3015,7 +3016,7 @@ public:
                                 return nullptr;
                             }
                             const A_Const* localConst = nullptr;
-                            if (NodeTag(rawArg) == T_TypeCast) { 
+                            if (NodeTag(rawArg) == T_TypeCast) {
                                 auto localCast = CAST_NODE(TypeCast, rawArg)->arg;
                                 if (NodeTag(localCast) != T_A_Const) {
                                     AddError(TStringBuilder() << "Expected a_const in cast, but got something wrong: " << NodeTag(localCast));
@@ -3043,7 +3044,7 @@ public:
                             NodeNotImplemented(def);
                             return nullptr;
                     }
-			        break;
+                    break;
                 }
                 default:
                     NodeNotImplemented(rawNode);
@@ -3054,7 +3055,7 @@ public:
         std::vector<TAstNode*> actions { QL(QA("alterColumns"), QVL(alterColumns.data(), alterColumns.size())) };
 
         options.push_back(
-            QL(QA("actions"), 
+            QL(QA("actions"),
                QVL(actions.data(), actions.size())
             )
         );
@@ -4037,7 +4038,7 @@ public:
             for (const auto& s : argStrs) {
                 concatArgs.push_back(L(A("Key"), QL(QA("table"),L(A("String"), QAX(s)))));
             }
-            
+
             key = VL(concatArgs);
         } else if (lowerName == "concat_view") {
             if (argStrs.size() % 2 != 0) {
@@ -4048,11 +4049,11 @@ public:
             TVector<TAstNode*> concatArgs;
             concatArgs.push_back(A("MrTableConcat"));
             for (ui32 i = 0; i < argStrs.size(); i += 2) {
-                concatArgs.push_back(L(A("Key"), 
+                concatArgs.push_back(L(A("Key"),
                     QL(QA("table"),L(A("String"), QAX(argStrs[i]))),
                     QL(QA("view"),L(A("String"), QAX(argStrs[i + 1])))));
             }
-            
+
             key = VL(concatArgs);
         } else if (lowerName == "range") {
             if (argStrs.size() > 5) {
@@ -4094,8 +4095,8 @@ public:
                     A("item"));
             } else {
                 expr = L(A("Apply"),L(A("Udf"),QA("Re2.Match"),
-                    QL(L(A("Apply"), 
-                        L(A("Udf"), QA("Re2.PatternFromLike")), 
+                    QL(L(A("Apply"),
+                        L(A("Udf"), QA("Re2.PatternFromLike")),
                         L(A("String"),QAX(argStrs[1]))),L(A("Null")))),
                     A("item"));
             }
@@ -5806,8 +5807,8 @@ public:
 
         if (!leftType) {
             return false;
-        } 
-        
+        }
+
         if (procedureName.empty()) {
             return false;
         }
@@ -6194,13 +6195,13 @@ public:
         desc.Family = familyName;
         TVector<NPg::TAmOpDesc> ops;
         TVector<NPg::TAmProcDesc> procs;
-        
+
         for (int i = 0; i < ListLength(value->items); ++i) {
             auto node = LIST_CAST_NTH(CreateOpClassItem, value->items, i);
             if (node->itemtype != OPCLASS_ITEM_OPERATOR && node->itemtype != OPCLASS_ITEM_FUNCTION) {
                 continue;
             }
-            
+
             if (ListLength(node->name->objname) != 1) {
                 return false;
             }
@@ -6422,4 +6423,47 @@ std::unique_ptr<NYql::NPg::ISqlLanguageParser> CreateSqlLanguageParser() {
     return std::make_unique<TSqlLanguageParser>();
 }
 
+class TTranslator : public NSQLTranslation::ITranslator {
+public:
+    NSQLTranslation::ILexer::TPtr MakeLexer(const NSQLTranslation::TTranslationSettings& settings) final {
+        Y_UNUSED(settings);
+        ythrow yexception() << "Unsupported method";
+    }
+
+    NYql::TAstParseResult TextToAst(const TString& query, const NSQLTranslation::TTranslationSettings& settings,
+        NYql::TWarningRules* warningRules, NYql::TStmtParseInfo* stmtParseInfo) final {
+        Y_UNUSED(warningRules);
+        return PGToYql(query, settings, stmtParseInfo);
+    }
+
+    google::protobuf::Message* TextToMessage(const TString& query, const TString& queryName,
+        NYql::TIssues& issues, size_t maxErrors, const NSQLTranslation::TTranslationSettings& settings) final {
+        Y_UNUSED(query);
+        Y_UNUSED(queryName);
+        Y_UNUSED(issues);
+        Y_UNUSED(maxErrors);
+        Y_UNUSED(settings);
+        ythrow yexception() << "Unsupported method";
+    }
+
+    NYql::TAstParseResult TextAndMessageToAst(const TString& query, const google::protobuf::Message& protoAst,
+        const NSQLTranslation::TSQLHints& hints, const NSQLTranslation::TTranslationSettings& settings) final {
+        Y_UNUSED(query);
+        Y_UNUSED(protoAst);
+        Y_UNUSED(hints);
+        Y_UNUSED(settings);
+        ythrow yexception() << "Unsupported method";
+    }
+
+    TVector<NYql::TAstParseResult> TextToManyAst(const TString& query, const NSQLTranslation::TTranslationSettings& settings,
+        NYql::TWarningRules* warningRules, TVector<NYql::TStmtParseInfo>* stmtParseInfo) final {
+        Y_UNUSED(warningRules);
+        return PGToYqlStatements(query, settings, stmtParseInfo);
+    }
+};
+
+NSQLTranslation::TTranslatorPtr MakeTranslator() {
+    return MakeIntrusive<TTranslator>();
+}
+
 } // NSQLTranslationPG
diff --git a/yql/essentials/sql/pg_dummy/pg_sql_dummy.cpp b/yql/essentials/sql/pg_dummy/pg_sql_dummy.cpp
index b2d1cd1c6d..ddf7f42ca7 100644
--- a/yql/essentials/sql/pg_dummy/pg_sql_dummy.cpp
+++ b/yql/essentials/sql/pg_dummy/pg_sql_dummy.cpp
@@ -2,6 +2,7 @@
 
 #include <yql/essentials/minikql/computation/mkql_computation_node_pack_impl.h>
 #include <yql/essentials/minikql/mkql_buffer.h>
+#include <yql/essentials/sql/settings/translator.h>
 
 namespace NSQLTranslationPG {
 
@@ -33,6 +34,10 @@ std::unique_ptr<NYql::NPg::ISqlLanguageParser> CreateSqlLanguageParser() {
     throw yexception() << "CreateSqlLanguageParser: PG types are not supported";
 }
 
+NSQLTranslation::TTranslatorPtr MakeTranslator() {
+    return NSQLTranslation::MakeDummyTranslator("pg");
+}
+
 } // NSQLTranslationPG
 
 namespace NYql {
diff --git a/yql/essentials/sql/pg_dummy/ya.make b/yql/essentials/sql/pg_dummy/ya.make
index 0341787faf..10615731c0 100644
--- a/yql/essentials/sql/pg_dummy/ya.make
+++ b/yql/essentials/sql/pg_dummy/ya.make
@@ -8,6 +8,7 @@ PROVIDES(
 PEERDIR(
     yql/essentials/parser/pg_wrapper/interface
     yql/essentials/minikql
+    yql/essentials/sql/settings
 )
 
 SRCS(
diff --git a/yql/essentials/sql/settings/translator.cpp b/yql/essentials/sql/settings/translator.cpp
new file mode 100644
index 0000000000..92e8c011b8
--- /dev/null
+++ b/yql/essentials/sql/settings/translator.cpp
@@ -0,0 +1,70 @@
+#include "translator.h"
+
+namespace NSQLTranslation {
+
+namespace {
+
+class TDummyTranslator : public ITranslator {
+public:
+    TDummyTranslator(const TString& name)
+        : Name_(name)
+    {}
+
+    NSQLTranslation::ILexer::TPtr MakeLexer(const NSQLTranslation::TTranslationSettings& settings) final {
+        Y_UNUSED(settings);
+        ThrowNotSupported();
+    }
+
+    NYql::TAstParseResult TextToAst(const TString& query, const NSQLTranslation::TTranslationSettings& settings,
+        NYql::TWarningRules* warningRules, NYql::TStmtParseInfo* stmtParseInfo) final {
+        Y_UNUSED(query);
+        Y_UNUSED(settings);
+        Y_UNUSED(warningRules);
+        Y_UNUSED(stmtParseInfo);
+        ThrowNotSupported();
+    }
+
+    google::protobuf::Message* TextToMessage(const TString& query, const TString& queryName,
+        NYql::TIssues& issues, size_t maxErrors, const TTranslationSettings& settings) final {
+        Y_UNUSED(query);
+        Y_UNUSED(queryName);
+        Y_UNUSED(issues);
+        Y_UNUSED(maxErrors);
+        Y_UNUSED(settings);
+        ThrowNotSupported();
+    }
+
+    NYql::TAstParseResult TextAndMessageToAst(const TString& query, const google::protobuf::Message& protoAst,
+        const TSQLHints& hints, const TTranslationSettings& settings) final {
+        Y_UNUSED(query);
+        Y_UNUSED(protoAst);
+        Y_UNUSED(hints);
+        Y_UNUSED(settings);
+        ThrowNotSupported();
+    }
+
+    TVector<NYql::TAstParseResult> TextToManyAst(const TString& query, const TTranslationSettings& settings,
+        NYql::TWarningRules* warningRules, TVector<NYql::TStmtParseInfo>* stmtParseInfo) final {
+        Y_UNUSED(query);
+        Y_UNUSED(settings);
+        Y_UNUSED(warningRules);
+        Y_UNUSED(stmtParseInfo);
+        ThrowNotSupported();
+    }
+
+private:
+    [[noreturn]] void ThrowNotSupported() {
+        throw yexception() << "Translator '" << Name_ << "' is not supported";
+    }
+
+private:
+    const TString Name_;
+};
+
+}
+
+TTranslatorPtr MakeDummyTranslator(const TString& name) {
+    return MakeIntrusive<TDummyTranslator>(name);
+}
+
+}  // namespace NSQLTranslation
diff --git a/yql/essentials/sql/settings/translator.h b/yql/essentials/sql/settings/translator.h
new file mode 100644
index 0000000000..aa8ef5ac5e
--- /dev/null
+++ b/yql/essentials/sql/settings/translator.h
@@ -0,0 +1,30 @@
+#pragma once
+#include "translation_settings.h"
+
+#include <yql/essentials/parser/lexer_common/lexer.h>
+#include <yql/essentials/parser/lexer_common/hints.h>
+#include <yql/essentials/public/issue/yql_warning.h>
+#include <yql/essentials/ast/yql_ast.h>
+
+namespace NSQLTranslation {
+
+class ITranslator : public TThrRefBase {
+public:
+    virtual ~ITranslator() = default;
+
+    virtual ILexer::TPtr MakeLexer(const TTranslationSettings& settings) = 0;
+    virtual NYql::TAstParseResult TextToAst(const TString& query, const TTranslationSettings& settings,
+        NYql::TWarningRules* warningRules, NYql::TStmtParseInfo* stmtParseInfo) = 0;
+    virtual google::protobuf::Message* TextToMessage(const TString& query, const TString& queryName,
+        NYql::TIssues& issues, size_t maxErrors, const TTranslationSettings& settings) = 0;
+    virtual NYql::TAstParseResult TextAndMessageToAst(const TString& query, const google::protobuf::Message& protoAst,
+        const TSQLHints& hints, const TTranslationSettings& settings) = 0;
+    virtual TVector<NYql::TAstParseResult> TextToManyAst(const TString& query, const TTranslationSettings& settings,
+            NYql::TWarningRules* warningRules, TVector<NYql::TStmtParseInfo>* stmtParseInfo) = 0;
+};
+
+using TTranslatorPtr = TIntrusivePtr<ITranslator>;
+
+TTranslatorPtr MakeDummyTranslator(const TString& name);
+
+}  // namespace NSQLTranslation
diff --git a/yql/essentials/sql/settings/ya.make b/yql/essentials/sql/settings/ya.make
index affdcbf303..784aa84d4f 100644
--- a/yql/essentials/sql/settings/ya.make
+++ b/yql/essentials/sql/settings/ya.make
@@ -3,11 +3,13 @@ LIBRARY()
 SRCS(
     partitioning.cpp
     translation_settings.cpp
+    translator.cpp
 )
 
 PEERDIR(
     library/cpp/deprecated/split
     library/cpp/json
+    yql/essentials/public/issue
     yql/essentials/core/issue
     yql/essentials/core/pg_settings
     yql/essentials/core/issue/protos
diff --git a/yql/essentials/sql/sql.cpp b/yql/essentials/sql/sql.cpp
index d38fff8838..9e18a1bb01 100644
--- a/yql/essentials/sql/sql.cpp
+++ b/yql/essentials/sql/sql.cpp
@@ -14,7 +14,7 @@
 
 namespace NSQLTranslation {
 
-    NYql::TAstParseResult SqlToYql(const TString& query, const TTranslationSettings& settings,
+    NYql::TAstParseResult SqlToYql(const TTranslators& translators, const TString& query, const TTranslationSettings& settings,
         NYql::TWarningRules* warningRules, NYql::TStmtParseInfo* stmtParseInfo, TTranslationSettings* effectiveSettings)
     {
         NYql::TAstParseResult result;
@@ -45,7 +45,7 @@ namespace NSQLTranslation {
         }
 
         if (parsedSettings.PgParser) {
-            return NSQLTranslationPG::PGToYql(query, parsedSettings, stmtParseInfo);
+            return translators.PG->TextToAst(query, parsedSettings, warningRules, stmtParseInfo);
         }
 
         switch (parsedSettings.SyntaxVersion) {
@@ -62,9 +62,9 @@ namespace NSQLTranslation {
                     return result;
                 }
 
-                return NSQLTranslationV0::SqlToYql(query, parsedSettings, warningRules);
+                return translators.V0->TextToAst(query, parsedSettings, warningRules, nullptr);
             case 1:
-                return NSQLTranslationV1::SqlToYql(query, parsedSettings, warningRules);
+                return translators.V1->TextToAst(query, parsedSettings, warningRules, nullptr);
             default:
                 result.Issues.AddIssue(NYql::YqlIssue(NYql::TPosition(), NYql::TIssuesIds::DEFAULT_ERROR,
                     TStringBuilder() << "Unknown SQL syntax version: " << parsedSettings.SyntaxVersion));
@@ -72,7 +72,12 @@ namespace NSQLTranslation {
         }
     }
 
-    google::protobuf::Message* SqlAST(const TString& query, const TString& queryName, NYql::TIssues& issues,
+    NYql::TAstParseResult SqlToYql(const TString& query, const TTranslationSettings& settings,
+        NYql::TWarningRules* warningRules, NYql::TStmtParseInfo* stmtParseInfo, TTranslationSettings* effectiveSettings) {
+        return SqlToYql(MakeAllTranslators(), query, settings, warningRules, stmtParseInfo, effectiveSettings);
+    }
+
+    google::protobuf::Message* SqlAST(const TTranslators& translators, const TString& query, const TString& queryName, NYql::TIssues& issues,
         size_t maxErrors, const TTranslationSettings& settings, ui16* actualSyntaxVersion)
     {
         TTranslationSettings parsedSettings(settings);
@@ -98,9 +103,9 @@ namespace NSQLTranslation {
                     return nullptr;
                 }
 
-                return NSQLTranslationV0::SqlAST(query, queryName, issues, maxErrors, settings.Arena);
+                return translators.V0->TextToMessage(query, queryName, issues, maxErrors, settings);
             case 1:
-                return NSQLTranslationV1::SqlAST(query, queryName, issues, maxErrors, parsedSettings.AnsiLexer, parsedSettings.Antlr4Parser, parsedSettings.TestAntlr4, settings.Arena);
+                return translators.V1->TextToMessage(query, queryName, issues, maxErrors, parsedSettings);
             default:
                 issues.AddIssue(NYql::YqlIssue(NYql::TPosition(), NYql::TIssuesIds::DEFAULT_ERROR,
                     TStringBuilder() << "Unknown SQL syntax version: " << parsedSettings.SyntaxVersion));
@@ -108,7 +113,12 @@ namespace NSQLTranslation {
         }
     }
 
-    ILexer::TPtr SqlLexer(const TString& query, NYql::TIssues& issues, const TTranslationSettings& settings, ui16* actualSyntaxVersion)
+    google::protobuf::Message* SqlAST(const TString& query, const TString& queryName, NYql::TIssues& issues,
+        size_t maxErrors, const TTranslationSettings& settings, ui16* actualSyntaxVersion) {
+        return SqlAST(MakeAllTranslators(), query, queryName, issues, maxErrors, settings, actualSyntaxVersion);
+    }
+
+    ILexer::TPtr SqlLexer(const TTranslators& translators, const TString& query, NYql::TIssues& issues, const TTranslationSettings& settings, ui16* actualSyntaxVersion)
     {
         TTranslationSettings parsedSettings(settings);
         if (!ParseTranslationSettings(query, parsedSettings, issues)) {
@@ -133,9 +143,9 @@ namespace NSQLTranslation {
                     return {};
                 }
 
-                return NSQLTranslationV0::MakeLexer();
+                return translators.V0->MakeLexer(parsedSettings);
             case 1:
-                return NSQLTranslationV1::MakeLexer(parsedSettings.AnsiLexer, parsedSettings.Antlr4Parser);
+                return translators.V1->MakeLexer(parsedSettings);
             default:
                 issues.AddIssue(NYql::YqlIssue(NYql::TPosition(), NYql::TIssuesIds::DEFAULT_ERROR,
                     TStringBuilder() << "Unknown SQL syntax version: " << parsedSettings.SyntaxVersion));
@@ -143,7 +153,12 @@ namespace NSQLTranslation {
         }
     }
 
-    NYql::TAstParseResult SqlASTToYql(const TString& query, const google::protobuf::Message& protoAst, const TSQLHints& hints, const TTranslationSettings& settings) {
+    ILexer::TPtr SqlLexer(const TString& query, NYql::TIssues& issues, const TTranslationSettings& settings, ui16* actualSyntaxVersion) {
+        return SqlLexer(MakeAllTranslators(), query, issues, settings, actualSyntaxVersion);
+    }
+
+    NYql::TAstParseResult SqlASTToYql(const TTranslators& translators, const TString& query,
+        const google::protobuf::Message& protoAst, const TSQLHints& hints, const TTranslationSettings& settings) {
         NYql::TAstParseResult result;
         switch (settings.SyntaxVersion) {
             case 0:
@@ -159,9 +174,9 @@ namespace NSQLTranslation {
                     return result;
                 }
 
-                return NSQLTranslationV0::SqlASTToYql(protoAst, settings);
+                return translators.V0->TextAndMessageToAst(query, protoAst, hints, settings);
             case 1:
-                return NSQLTranslationV1::SqlASTToYql(query, protoAst, hints, settings);
+                return translators.V1->TextAndMessageToAst(query, protoAst, hints, settings);
             default:
                 result.Issues.AddIssue(NYql::YqlIssue(NYql::TPosition(), NYql::TIssuesIds::DEFAULT_ERROR,
                     TStringBuilder() << "Unknown SQL syntax version: " << settings.SyntaxVersion));
@@ -169,8 +184,14 @@ namespace NSQLTranslation {
         }
     }
 
-    TVector<NYql::TAstParseResult> SqlToAstStatements(const TString& query, const TTranslationSettings& settings,
-        NYql::TWarningRules* warningRules, ui16* actualSyntaxVersion, TVector<NYql::TStmtParseInfo>* stmtParseInfo)
+    NYql::TAstParseResult SqlASTToYql(const TString& query, const google::protobuf::Message& protoAst,
+        const TSQLHints& hints, const TTranslationSettings& settings) {
+        return SqlASTToYql(MakeAllTranslators(), query, protoAst, hints, settings);
+    }
+
+    TVector<NYql::TAstParseResult> SqlToAstStatements(const TTranslators& translators, const TString& query,
+        const TTranslationSettings& settings, NYql::TWarningRules* warningRules, ui16* actualSyntaxVersion,
+        TVector<NYql::TStmtParseInfo>* stmtParseInfo)
     {
         TVector<NYql::TAstParseResult> result;
         NYql::TIssues issues;
@@ -201,16 +222,16 @@ namespace NSQLTranslation {
         }
 
         if (parsedSettings.PgParser) {
-            return NSQLTranslationPG::PGToYqlStatements(query, parsedSettings, stmtParseInfo);
+            return translators.PG->TextToManyAst(query, parsedSettings, warningRules, stmtParseInfo);
         }
 
         switch (parsedSettings.SyntaxVersion) {
             case 0:
                 issues.AddIssue(NYql::YqlIssue(NYql::TPosition(), NYql::TIssuesIds::DEFAULT_ERROR,
                     "V0 syntax is disabled"));
-                return {};
+                return translators.V0->TextToManyAst(query, parsedSettings, warningRules, stmtParseInfo);
             case 1:
-                return NSQLTranslationV1::SqlToAstStatements(query, parsedSettings, warningRules, stmtParseInfo);
+                return translators.V1->TextToManyAst(query, parsedSettings, warningRules, stmtParseInfo);
             default:
                 issues.AddIssue(NYql::YqlIssue(NYql::TPosition(), NYql::TIssuesIds::DEFAULT_ERROR,
                     TStringBuilder() << "Unknown SQL syntax version: " << parsedSettings.SyntaxVersion));
@@ -218,4 +239,23 @@ namespace NSQLTranslation {
         }
     }
 
+    TVector<NYql::TAstParseResult> SqlToAstStatements(const TString& query, const TTranslationSettings& settings,
+        NYql::TWarningRules* warningRules, ui16* actualSyntaxVersion, TVector<NYql::TStmtParseInfo>* stmtParseInfo) {
+        return SqlToAstStatements(MakeAllTranslators(), query, settings, warningRules, actualSyntaxVersion, stmtParseInfo);
+    }
+
+    TTranslators MakeAllTranslators() {
+        return TTranslators(
+            NSQLTranslationV0::MakeTranslator(),
+            NSQLTranslationV1::MakeTranslator(),
+            NSQLTranslationPG::MakeTranslator()
+        );
+    }
+
+    TTranslators::TTranslators(TTranslatorPtr v0, TTranslatorPtr v1, TTranslatorPtr pg)
+        : V0(v0 ? v0 : MakeDummyTranslator("v0"))
+        , V1(v1 ? v1 : MakeDummyTranslator("v1"))
+        , PG(pg ? pg : MakeDummyTranslator("pg"))
+    {}
+
 }  // namespace NSQLTranslation
diff --git a/yql/essentials/sql/sql.h b/yql/essentials/sql/sql.h
index 891ea4f684..250cefc2b1 100644
--- a/yql/essentials/sql/sql.h
+++ b/yql/essentials/sql/sql.h
@@ -7,6 +7,7 @@
 #include <yql/essentials/public/issue/yql_issue_manager.h>
 #include <yql/essentials/ast/yql_ast.h>
 #include <yql/essentials/sql/settings/translation_settings.h>
+#include <yql/essentials/sql/settings/translator.h>
 
 #include <util/generic/hash.h>
 #include <util/generic/hash_set.h>
@@ -15,16 +16,37 @@
 
 namespace NSQLTranslation {
 
+    struct TTranslators {
+        TTranslatorPtr const V0;
+        TTranslatorPtr const V1;
+        TTranslatorPtr const PG;
+
+        TTranslators(TTranslatorPtr v0, TTranslatorPtr v1, TTranslatorPtr pg);
+    };
+
+    //FIXME drop this function and overloads without translators
+    TTranslators MakeAllTranslators();
+
     NYql::TAstParseResult SqlToYql(const TString& query, const TTranslationSettings& settings,
         NYql::TWarningRules* warningRules = nullptr, NYql::TStmtParseInfo* stmtParseInfo = nullptr,
         TTranslationSettings* effectiveSettings = nullptr);
+    NYql::TAstParseResult SqlToYql(const TTranslators& translators, const TString& query, const TTranslationSettings& settings,
+        NYql::TWarningRules* warningRules = nullptr, NYql::TStmtParseInfo* stmtParseInfo = nullptr,
+        TTranslationSettings* effectiveSettings = nullptr);
+
     google::protobuf::Message* SqlAST(const TString& query, const TString& queryName, NYql::TIssues& issues, size_t maxErrors,
         const TTranslationSettings& settings = {}, ui16* actualSyntaxVersion = nullptr);
+    google::protobuf::Message* SqlAST(const TTranslators& translators, const TString& query, const TString& queryName, NYql::TIssues& issues, size_t maxErrors,
+        const TTranslationSettings& settings = {}, ui16* actualSyntaxVersion = nullptr);
+
     ILexer::TPtr SqlLexer(const TString& query, NYql::TIssues& issues, const TTranslationSettings& settings = {}, ui16* actualSyntaxVersion = nullptr);
+    ILexer::TPtr SqlLexer(const TTranslators& translators, const TString& query, NYql::TIssues& issues, const TTranslationSettings& settings = {}, ui16* actualSyntaxVersion = nullptr);
 
     NYql::TAstParseResult SqlASTToYql(const TString& query, const google::protobuf::Message& protoAst, const TSQLHints& hints, const TTranslationSettings& settings);
+    NYql::TAstParseResult SqlASTToYql(const TTranslators& translators, const TString& query, const google::protobuf::Message& protoAst, const TSQLHints& hints, const TTranslationSettings& settings);
 
     TVector<NYql::TAstParseResult> SqlToAstStatements(const TString& query, const TTranslationSettings& settings,
         NYql::TWarningRules* warningRules = nullptr, ui16* actualSyntaxVersion = nullptr, TVector<NYql::TStmtParseInfo>* stmtParseInfo = nullptr);
-
-}  // namespace NSQLTranslationV0
+    TVector<NYql::TAstParseResult> SqlToAstStatements(const TTranslators& translators, const TString& query, const TTranslationSettings& settings,
+        NYql::TWarningRules* warningRules = nullptr, ui16* actualSyntaxVersion = nullptr, TVector<NYql::TStmtParseInfo>* stmtParseInfo = nullptr);
+}  // namespace NSQLTranslation
diff --git a/yql/essentials/sql/v0/sql.cpp b/yql/essentials/sql/v0/sql.cpp
index caf61bdd0e..f83a016b22 100644
--- a/yql/essentials/sql/v0/sql.cpp
+++ b/yql/essentials/sql/v0/sql.cpp
@@ -1,5 +1,6 @@
 #include "sql.h"
 
+#include <yql/essentials/sql/v0/lexer/lexer.h>
 #include "context.h"
 #include "node.h"
 
@@ -5315,4 +5316,43 @@ NYql::TAstParseResult SqlToYql(const TString& query, const NSQLTranslation::TTra
     return res;
 }
 
+class TTranslator : public NSQLTranslation::ITranslator {
+public:
+    NSQLTranslation::ILexer::TPtr MakeLexer(const NSQLTranslation::TTranslationSettings& settings) final {
+        Y_UNUSED(settings);
+        return NSQLTranslationV0::MakeLexer();
+    }
+
+    NYql::TAstParseResult TextToAst(const TString& query, const NSQLTranslation::TTranslationSettings& settings,
+        NYql::TWarningRules* warningRules, NYql::TStmtParseInfo* stmtParseInfo) final {
+        Y_UNUSED(stmtParseInfo);
+        return SqlToYql(query, settings, warningRules);
+    }
+
+    google::protobuf::Message* TextToMessage(const TString& query, const TString& queryName,
+        NYql::TIssues& issues, size_t maxErrors, const NSQLTranslation::TTranslationSettings& settings) final {
+        return SqlAST(query, queryName, issues, maxErrors, settings.Arena);
+    }
+
+    NYql::TAstParseResult TextAndMessageToAst(const TString& query, const google::protobuf::Message& protoAst,
+        const NSQLTranslation::TSQLHints& hints, const NSQLTranslation::TTranslationSettings& settings) final {
+        Y_UNUSED(query);
+        Y_UNUSED(hints);
+        return SqlASTToYql(protoAst, settings);
+    }
+
+    TVector<NYql::TAstParseResult> TextToManyAst(const TString& query, const NSQLTranslation::TTranslationSettings& settings,
+        NYql::TWarningRules* warningRules, TVector<NYql::TStmtParseInfo>* stmtParseInfo) final {
+        Y_UNUSED(query);
+        Y_UNUSED(settings);
+        Y_UNUSED(warningRules);
+        Y_UNUSED(stmtParseInfo);
+        return {};
+    }
+};
+
+NSQLTranslation::TTranslatorPtr MakeTranslator() {
+    return MakeIntrusive<TTranslator>();
+}
+
 } // namespace NSQLTranslationV0
diff --git a/yql/essentials/sql/v0/sql.h b/yql/essentials/sql/v0/sql.h
index 66516adce7..dffcbdd3de 100644
--- a/yql/essentials/sql/v0/sql.h
+++ b/yql/essentials/sql/v0/sql.h
@@ -5,6 +5,7 @@
 #include <yql/essentials/public/issue/yql_warning.h>
 #include <yql/essentials/public/issue/yql_issue_manager.h>
 #include <yql/essentials/sql/settings/translation_settings.h>
+#include <yql/essentials/sql/settings/translator.h>
 
 #include <google/protobuf/message.h>
 
@@ -13,5 +14,6 @@ namespace NSQLTranslationV0 {
     NYql::TAstParseResult SqlToYql(const TString& query, const NSQLTranslation::TTranslationSettings& settings, NYql::TWarningRules* warningRules = nullptr);
     google::protobuf::Message* SqlAST(const TString& query, const TString& queryName, NYql::TIssues& err, size_t maxErrors, google::protobuf::Arena* arena = nullptr);
     NYql::TAstParseResult SqlASTToYql(const google::protobuf::Message& protoAst, const NSQLTranslation::TTranslationSettings& settings);
+    NSQLTranslation::TTranslatorPtr MakeTranslator();
 
 }  // namespace NSQLTranslationV0
diff --git a/yql/essentials/sql/v0/ya.make b/yql/essentials/sql/v0/ya.make
index 92fc1a21f8..e0f6936e94 100644
--- a/yql/essentials/sql/v0/ya.make
+++ b/yql/essentials/sql/v0/ya.make
@@ -11,6 +11,7 @@ PEERDIR(
     yql/essentials/core/issue/protos
     yql/essentials/parser/proto_ast/collect_issues
     yql/essentials/parser/proto_ast/gen/v0
+    yql/essentials/sql/v0/lexer
 )
 
 SRCS(
diff --git a/yql/essentials/sql/v1/sql.cpp b/yql/essentials/sql/v1/sql.cpp
index f131653f92..2fc80a2fe8 100644
--- a/yql/essentials/sql/v1/sql.cpp
+++ b/yql/essentials/sql/v1/sql.cpp
@@ -275,4 +275,37 @@ bool SplitQueryToStatements(const TString& query, TVector<TString>& statements,
     return true;
 }
 
+class TTranslator : public NSQLTranslation::ITranslator {
+public:
+    NSQLTranslation::ILexer::TPtr MakeLexer(const NSQLTranslation::TTranslationSettings& settings) final {
+        return NSQLTranslationV1::MakeLexer(settings.AnsiLexer, settings.Antlr4Parser);
+    }
+
+    NYql::TAstParseResult TextToAst(const TString& query, const NSQLTranslation::TTranslationSettings& settings,
+        NYql::TWarningRules* warningRules, NYql::TStmtParseInfo* stmtParseInfo) final {
+        Y_UNUSED(stmtParseInfo);
+        return SqlToYql(query, settings, warningRules);
+    }
+
+    google::protobuf::Message* TextToMessage(const TString& query, const TString& queryName,
+        NYql::TIssues& issues, size_t maxErrors, const NSQLTranslation::TTranslationSettings& settings) final {
+        return SqlAST(query, queryName, issues, maxErrors, settings.AnsiLexer, settings.Antlr4Parser,
+            settings.TestAntlr4, settings.Arena);
+    }
+
+    NYql::TAstParseResult TextAndMessageToAst(const TString& query, const google::protobuf::Message& protoAst,
+        const NSQLTranslation::TSQLHints& hints, const NSQLTranslation::TTranslationSettings& settings) final {
+        return SqlASTToYql(query, protoAst, hints, settings);
+    }
+
+    TVector<NYql::TAstParseResult> TextToManyAst(const TString& query, const NSQLTranslation::TTranslationSettings& settings,
+        NYql::TWarningRules* warningRules, TVector<NYql::TStmtParseInfo>* stmtParseInfo) final {
+        return SqlToAstStatements(query, settings, warningRules, stmtParseInfo);
+    }
+};
+
+NSQLTranslation::TTranslatorPtr MakeTranslator() {
+    return MakeIntrusive<TTranslator>();
+}
+
 } // namespace NSQLTranslationV1
diff --git a/yql/essentials/sql/v1/sql.h b/yql/essentials/sql/v1/sql.h
index 63a4ee153f..7f0ded1a55 100644
--- a/yql/essentials/sql/v1/sql.h
+++ b/yql/essentials/sql/v1/sql.h
@@ -7,6 +7,7 @@
 #include <yql/essentials/public/issue/yql_warning.h>
 #include <yql/essentials/public/issue/yql_issue_manager.h>
 #include <yql/essentials/sql/settings/translation_settings.h>
+#include <yql/essentials/sql/settings/translator.h>
 
 #include <google/protobuf/message.h>
 
@@ -27,4 +28,5 @@ namespace NSQLTranslationV1 {
     bool SplitQueryToStatements(const TString& query, TVector<TString>& statements, NYql::TIssues& issues,
         const NSQLTranslation::TTranslationSettings& settings);
 
+    NSQLTranslation::TTranslatorPtr MakeTranslator();
 }  // namespace NSQLTranslationV1