From 11433e1637a5eb428009b297fe7800f3ae77acbb Mon Sep 17 00:00:00 2001
From: Orlov Pavel <orlov.pg@phystech.edu>
Date: Wed, 4 Sep 2024 17:57:00 +0300
Subject: [PATCH] Migrating from antlr3 to antlr4 (#2977)

Co-authored-by: root <p.g.orlov@tinkoff.ru>
---
 .gitignore                                    |    1 +
 .../yql/parser/lexer_common/ut/hints_ut.cpp   |   19 +-
 .../yql/parser/proto_ast/gen/jsonpath/ya.make |    5 +-
 .../yql/parser/proto_ast/gen/v0/ya.make       |    4 +
 .../yql/parser/proto_ast/gen/v1/ya.make       |    4 +
 .../yql/parser/proto_ast/gen/v1_ansi/ya.make  |    4 +
 .../gen/v1_ansi_antlr4/epilogue.cmake         |   10 +
 .../proto_ast/gen/v1_ansi_antlr4/ya.make      |   52 +
 .../proto_ast/gen/v1_antlr4/epilogue.cmake    |    9 +
 .../parser/proto_ast/gen/v1_antlr4/ya.make    |   52 +
 .../proto_ast/gen/v1_proto_antlr4/ya.make.gen |   38 +
 .../gen/v1_proto_split_antlr4/epilogue.cmake  |    9 +
 .../gen/v1_proto_split_antlr4/update.sh       |    7 +
 .../gen/v1_proto_split_antlr4/ya.make         |   87 +
 ydb/library/yql/parser/proto_ast/gen/ya.make  |    2 +
 .../v4/tool/templates/codegen/Cpp/Cpp.stg.in  | 1425 ++++
 .../tool/templates/codegen/Cpp/Files.stg.in   |  347 +
 .../tool/templates/codegen/Java/Java.stg.in   |  459 ++
 .../v4/tool/templates/codegen/ya.make.incl    |   13 +
 .../yql/parser/proto_ast/proto_ast.cpp        |   11 +
 ydb/library/yql/parser/proto_ast/proto_ast.h  |  154 +-
 ydb/library/yql/parser/proto_ast/ya.make      |    1 +
 .../yql/sql/settings/translation_settings.cpp |    3 +
 .../yql/sql/settings/translation_settings.h   |    1 +
 ydb/library/yql/sql/sql.cpp                   |    2 +-
 ydb/library/yql/sql/v1/SQLv1Antlr4.g.in       | 2091 +++++
 ydb/library/yql/sql/v1/context.h              |    9 +
 ydb/library/yql/sql/v1/format/sql_format.cpp  |    9 +-
 .../yql/sql/v1/format/sql_format_ut.cpp       | 1621 +---
 ydb/library/yql/sql/v1/format/sql_format_ut.h | 1618 ++++
 .../sql/v1/format/sql_format_ut_antlr4.cpp    |   52 +
 .../yql/sql/v1/format/ut_antlr4/ya.make       |    7 +
 ydb/library/yql/sql/v1/format/ya.make         |    2 +
 ydb/library/yql/sql/v1/lexer/lexer.cpp        |   22 +-
 ydb/library/yql/sql/v1/lexer/lexer.h          |    2 +-
 ydb/library/yql/sql/v1/lexer/ya.make          |    2 +
 .../yql/sql/v1/proto_parser/proto_parser.cpp  |   29 +-
 .../yql/sql/v1/proto_parser/proto_parser.h    |    4 +-
 ydb/library/yql/sql/v1/proto_parser/ya.make   |    2 +
 ydb/library/yql/sql/v1/sql.cpp                |    8 +-
 ydb/library/yql/sql/v1/sql_expression.cpp     |  126 +-
 ydb/library/yql/sql/v1/sql_query.cpp          |   62 +-
 ydb/library/yql/sql/v1/sql_query.h            |   10 +-
 ydb/library/yql/sql/v1/sql_translation.cpp    |   46 +-
 ydb/library/yql/sql/v1/sql_ut.cpp             |    2 +-
 ydb/library/yql/sql/v1/sql_ut.h               |    4 +-
 ydb/library/yql/sql/v1/sql_ut_antlr4.cpp      | 7203 +++++++++++++++++
 ydb/library/yql/sql/v1/sql_ut_antlr4.h        |  226 +
 ydb/library/yql/sql/v1/ut_antlr4/ya.make      |   20 +
 ydb/library/yql/sql/v1/ya.make                |    3 +
 50 files changed, 14126 insertions(+), 1773 deletions(-)
 create mode 100644 ydb/library/yql/parser/proto_ast/gen/v1_ansi_antlr4/epilogue.cmake
 create mode 100644 ydb/library/yql/parser/proto_ast/gen/v1_ansi_antlr4/ya.make
 create mode 100644 ydb/library/yql/parser/proto_ast/gen/v1_antlr4/epilogue.cmake
 create mode 100644 ydb/library/yql/parser/proto_ast/gen/v1_antlr4/ya.make
 create mode 100644 ydb/library/yql/parser/proto_ast/gen/v1_proto_antlr4/ya.make.gen
 create mode 100644 ydb/library/yql/parser/proto_ast/gen/v1_proto_split_antlr4/epilogue.cmake
 create mode 100755 ydb/library/yql/parser/proto_ast/gen/v1_proto_split_antlr4/update.sh
 create mode 100644 ydb/library/yql/parser/proto_ast/gen/v1_proto_split_antlr4/ya.make
 create mode 100644 ydb/library/yql/parser/proto_ast/org/antlr/v4/tool/templates/codegen/Cpp/Cpp.stg.in
 create mode 100644 ydb/library/yql/parser/proto_ast/org/antlr/v4/tool/templates/codegen/Cpp/Files.stg.in
 create mode 100644 ydb/library/yql/parser/proto_ast/org/antlr/v4/tool/templates/codegen/Java/Java.stg.in
 create mode 100644 ydb/library/yql/parser/proto_ast/org/antlr/v4/tool/templates/codegen/ya.make.incl
 create mode 100644 ydb/library/yql/sql/v1/SQLv1Antlr4.g.in
 create mode 100644 ydb/library/yql/sql/v1/format/sql_format_ut.h
 create mode 100644 ydb/library/yql/sql/v1/format/sql_format_ut_antlr4.cpp
 create mode 100644 ydb/library/yql/sql/v1/format/ut_antlr4/ya.make
 create mode 100644 ydb/library/yql/sql/v1/sql_ut_antlr4.cpp
 create mode 100644 ydb/library/yql/sql/v1/sql_ut_antlr4.h
 create mode 100644 ydb/library/yql/sql/v1/ut_antlr4/ya.make

diff --git a/.gitignore b/.gitignore
index 87b7b54d294d..13059c619843 100644
--- a/.gitignore
+++ b/.gitignore
@@ -43,6 +43,7 @@ __pycache__/
 .idea/
 .vscode/
 .clangd
+.antlr/
 
 # KDevelop IDE
 *.kdev4
diff --git a/ydb/library/yql/parser/lexer_common/ut/hints_ut.cpp b/ydb/library/yql/parser/lexer_common/ut/hints_ut.cpp
index 2567bc1c7d33..1ffd5377c79d 100644
--- a/ydb/library/yql/parser/lexer_common/ut/hints_ut.cpp
+++ b/ydb/library/yql/parser/lexer_common/ut/hints_ut.cpp
@@ -8,9 +8,9 @@
 using namespace NSQLTranslation;
 using namespace NSQLTranslationV1;
 
-TSQLHints CollectHints(const TString& query) {
+TSQLHints CollectHints(const TString& query, bool antlr4Parser) {
     bool ansi = false;
-    auto lexer = MakeLexer(ansi);
+    auto lexer = MakeLexer(ansi, antlr4Parser);
     UNIT_ASSERT(lexer);
     TSQLHints result;
     NYql::TIssues issues;
@@ -27,7 +27,20 @@ TString SerializeHints(const TVector<TSQLHint>& hints) {
 Y_UNIT_TEST_SUITE(TLexerHintsTests) {
     Y_UNIT_TEST(Basic) {
         TString query = "/*+ some() */ SELECT /*+ foo(one) */ --+ bar(two)";
-        auto hintsWithPos = CollectHints(query);
+        auto hintsWithPos = CollectHints(query, false);
+        UNIT_ASSERT(hintsWithPos.size() == 1);
+        NYql::TPosition pos = hintsWithPos.begin()->first;
+        TVector<TSQLHint> hints = hintsWithPos.begin()->second;
+
+        UNIT_ASSERT_EQUAL(pos.Row, 1);
+        UNIT_ASSERT_EQUAL(pos.Column, 15);
+
+        TStringBuf expected = R"raw("foo":{"one"},"bar":{"two"})raw";
+        UNIT_ASSERT_NO_DIFF(SerializeHints(hints), expected);
+    }
+    Y_UNIT_TEST(Antlr4) {
+        TString query = "/*+ some() */ SELECT /*+ foo(one) */ --+ bar(two)";
+        auto hintsWithPos = CollectHints(query, true);
         UNIT_ASSERT(hintsWithPos.size() == 1);
         NYql::TPosition pos = hintsWithPos.begin()->first;
         TVector<TSQLHint> hints = hintsWithPos.begin()->second;
diff --git a/ydb/library/yql/parser/proto_ast/gen/jsonpath/ya.make b/ydb/library/yql/parser/proto_ast/gen/jsonpath/ya.make
index b050069fbc9f..557316988274 100644
--- a/ydb/library/yql/parser/proto_ast/gen/jsonpath/ya.make
+++ b/ydb/library/yql/parser/proto_ast/gen/jsonpath/ya.make
@@ -10,7 +10,6 @@ IF (CPP_PROTO)
     SET(PROTOBUF_SUFFIX_PATH .pb.h)
     SET(LEXER_PARSER_NAMESPACE NALP)
 
-
     CONFIGURE_FILE(${ARCADIA_ROOT}/ydb/library/yql/parser/proto_ast/org/antlr/codegen/templates/Cpp/Cpp.stg.in ${antlr_templates}/Cpp/Cpp.stg)
     CONFIGURE_FILE(${ARCADIA_ROOT}/ydb/library/yql/parser/proto_ast/org/antlr/codegen/templates/protobuf/protobuf.stg.in ${antlr_templates}/protobuf/protobuf.stg)
 
@@ -28,6 +27,10 @@ IF (CPP_PROTO)
 
     NO_COMPILER_WARNINGS()
 
+    ADDINCL(
+        GLOBAL contrib/libs/antlr4_cpp_runtime/src
+    )
+
     INCLUDE(${ARCADIA_ROOT}/ydb/library/yql/parser/proto_ast/org/antlr/codegen/templates/ya.make.incl)
 
     RUN_ANTLR(
diff --git a/ydb/library/yql/parser/proto_ast/gen/v0/ya.make b/ydb/library/yql/parser/proto_ast/gen/v0/ya.make
index 2037ad3f8645..15c84a512075 100644
--- a/ydb/library/yql/parser/proto_ast/gen/v0/ya.make
+++ b/ydb/library/yql/parser/proto_ast/gen/v0/ya.make
@@ -20,6 +20,10 @@ NO_COMPILER_WARNINGS()
 
 INCLUDE(${ARCADIA_ROOT}/ydb/library/yql/parser/proto_ast/org/antlr/codegen/templates/ya.make.incl)
 
+ADDINCL(
+    GLOBAL contrib/libs/antlr4_cpp_runtime/src
+)
+
 RUN_ANTLR(
     ${sql_grammar}
     -lib .
diff --git a/ydb/library/yql/parser/proto_ast/gen/v1/ya.make b/ydb/library/yql/parser/proto_ast/gen/v1/ya.make
index f5487a56a184..c3586e6050e6 100644
--- a/ydb/library/yql/parser/proto_ast/gen/v1/ya.make
+++ b/ydb/library/yql/parser/proto_ast/gen/v1/ya.make
@@ -28,6 +28,10 @@ ENDIF()
 
 NO_COMPILER_WARNINGS()
 
+ADDINCL(
+    GLOBAL contrib/libs/antlr4_cpp_runtime/src
+)
+
 INCLUDE(${ARCADIA_ROOT}/ydb/library/yql/parser/proto_ast/org/antlr/codegen/templates/ya.make.incl)
 
 RUN_ANTLR(
diff --git a/ydb/library/yql/parser/proto_ast/gen/v1_ansi/ya.make b/ydb/library/yql/parser/proto_ast/gen/v1_ansi/ya.make
index ebd0e8b70dc2..bd4614bc9475 100644
--- a/ydb/library/yql/parser/proto_ast/gen/v1_ansi/ya.make
+++ b/ydb/library/yql/parser/proto_ast/gen/v1_ansi/ya.make
@@ -28,6 +28,10 @@ ENDIF()
 
 NO_COMPILER_WARNINGS()
 
+ADDINCL(
+    GLOBAL contrib/libs/antlr4_cpp_runtime/src
+)
+
 INCLUDE(${ARCADIA_ROOT}/ydb/library/yql/parser/proto_ast/org/antlr/codegen/templates/ya.make.incl)
 
 RUN_ANTLR(
diff --git a/ydb/library/yql/parser/proto_ast/gen/v1_ansi_antlr4/epilogue.cmake b/ydb/library/yql/parser/proto_ast/gen/v1_ansi_antlr4/epilogue.cmake
new file mode 100644
index 000000000000..2559073edd72
--- /dev/null
+++ b/ydb/library/yql/parser/proto_ast/gen/v1_ansi_antlr4/epilogue.cmake
@@ -0,0 +1,10 @@
+set(GRAMMAR_STRING_CORE_SINGLE "~([']) | (QUOTE_SINGLE QUOTE_SINGLE)")
+set(GRAMMAR_STRING_CORE_DOUBLE "~([\"]) | (QUOTE_DOUBLE QUOTE_DOUBLE)")
+set(GRAMMAR_MULTILINE_COMMENT_CORE       "MULTILINE_COMMENT | .")
+
+configure_file(
+  ${CMAKE_SOURCE_DIR}/ydb/library/yql/sql/v1/SQLv1Antlr4.g.in
+  ${CMAKE_BINARY_DIR}/ydb/library/yql/parser/proto_ast/gen/v1_ansi_antlr4/SQLv1Antlr4.g
+)
+
+
diff --git a/ydb/library/yql/parser/proto_ast/gen/v1_ansi_antlr4/ya.make b/ydb/library/yql/parser/proto_ast/gen/v1_ansi_antlr4/ya.make
new file mode 100644
index 000000000000..c53f624301e8
--- /dev/null
+++ b/ydb/library/yql/parser/proto_ast/gen/v1_ansi_antlr4/ya.make
@@ -0,0 +1,52 @@
+LIBRARY()
+
+PEERDIR (
+    ydb/library/yql/parser/proto_ast/gen/v1_proto_split
+)
+
+SET(antlr_output ${ARCADIA_BUILD_ROOT}/${MODDIR})
+SET(antlr_templates ${antlr_output}/org/antlr/v4/tool/templates/codegen)
+SET(sql_grammar ${antlr_output}/SQLv1Antlr4.g)
+
+SET(ANTLR_PACKAGE_NAME NSQLv1Generated)
+SET(PROTOBUF_HEADER_PATH ydb/library/yql/parser/proto_ast/gen/v1_proto_split)
+SET(PROTOBUF_SUFFIX_PATH .pb.main.h)
+
+SET(LEXER_PARSER_NAMESPACE NALPAnsiAntlr4)
+
+SET(GRAMMAR_STRING_CORE_SINGLE "\"~([']) | (QUOTE_SINGLE QUOTE_SINGLE)\"")
+SET(GRAMMAR_STRING_CORE_DOUBLE "\"~([#DOUBLE_QUOTE#]) | (QUOTE_DOUBLE QUOTE_DOUBLE)\"")
+SET(GRAMMAR_MULTILINE_COMMENT_CORE       "\"MULTILINE_COMMENT | .\"")
+
+CONFIGURE_FILE(${ARCADIA_ROOT}/ydb/library/yql/parser/proto_ast/org/antlr/v4/tool/templates/codegen/Cpp/Cpp.stg.in ${antlr_templates}/Cpp/Cpp.stg)
+CONFIGURE_FILE(${ARCADIA_ROOT}/ydb/library/yql/parser/proto_ast/org/antlr/v4/tool/templates/codegen/Cpp/Files.stg.in ${antlr_templates}/Cpp/Files.stg)
+
+IF(EXPORT_CMAKE)
+    MANUAL_GENERATION(${sql_grammar})
+ELSE()
+    CONFIGURE_FILE(${ARCADIA_ROOT}/ydb/library/yql/sql/v1/SQLv1Antlr4.g.in ${sql_grammar})
+ENDIF()
+
+NO_COMPILER_WARNINGS()
+
+ADDINCL(
+    GLOBAL contrib/libs/antlr4_cpp_runtime/src
+)
+
+INCLUDE(${ARCADIA_ROOT}/ydb/library/yql/parser/proto_ast/org/antlr/v4/tool/templates/codegen/ya.make.incl)
+
+RUN_ANTLR4(
+    ${sql_grammar}
+    -no-listener
+    -package NALPAnsiAntlr4
+    -lib .
+    -o ${antlr_output}
+    IN ${sql_grammar} ${antlr_templates}/Cpp/Cpp.stg ${antlr_templates}/Cpp/Files.stg
+    OUT SQLv1Antlr4Parser.cpp SQLv1Antlr4Lexer.cpp SQLv1Antlr4Parser.h SQLv1Antlr4Lexer.h
+    OUTPUT_INCLUDES
+    ${PROTOBUF_HEADER_PATH}/SQLv1Parser.pb.main.h
+    ${STG_INCLUDES}
+    CWD ${antlr_output}
+)
+
+END()
diff --git a/ydb/library/yql/parser/proto_ast/gen/v1_antlr4/epilogue.cmake b/ydb/library/yql/parser/proto_ast/gen/v1_antlr4/epilogue.cmake
new file mode 100644
index 000000000000..4998610012eb
--- /dev/null
+++ b/ydb/library/yql/parser/proto_ast/gen/v1_antlr4/epilogue.cmake
@@ -0,0 +1,9 @@
+set(GRAMMAR_STRING_CORE_SINGLE "~(['\\]) | (BACKSLASH .)")
+set(GRAMMAR_STRING_CORE_DOUBLE "~([\"\\]) | (BACKSLASH .)")
+set(GRAMMAR_MULTILINE_COMMENT_CORE       ".")
+configure_file(
+  ${CMAKE_SOURCE_DIR}/ydb/library/yql/sql/v1/SQLv1Antlr4.g.in
+  ${CMAKE_BINARY_DIR}/ydb/library/yql/parser/proto_ast/gen/v1_antlr4/SQLv1Antlr4.g
+)
+
+
diff --git a/ydb/library/yql/parser/proto_ast/gen/v1_antlr4/ya.make b/ydb/library/yql/parser/proto_ast/gen/v1_antlr4/ya.make
new file mode 100644
index 000000000000..016150d2cedb
--- /dev/null
+++ b/ydb/library/yql/parser/proto_ast/gen/v1_antlr4/ya.make
@@ -0,0 +1,52 @@
+LIBRARY()
+
+PEERDIR (
+    ydb/library/yql/parser/proto_ast/gen/v1_proto_split
+)
+
+SET(antlr_output ${ARCADIA_BUILD_ROOT}/${MODDIR})
+SET(antlr_templates ${antlr_output}/org/antlr/v4/tool/templates/codegen)
+SET(sql_grammar ${antlr_output}/SQLv1Antlr4.g)
+
+SET(ANTLR_PACKAGE_NAME NSQLv1Generated)
+SET(PROTOBUF_HEADER_PATH ydb/library/yql/parser/proto_ast/gen/v1_proto_split)
+SET(PROTOBUF_SUFFIX_PATH .pb.main.h)
+
+SET(LEXER_PARSER_NAMESPACE NALPDefaultAntlr4)
+
+SET(GRAMMAR_STRING_CORE_SINGLE "\"~(['#BACKSLASH#]) | (BACKSLASH .)\"")
+SET(GRAMMAR_STRING_CORE_DOUBLE "\"~([#DOUBLE_QUOTE##BACKSLASH#]) | (BACKSLASH .)\"")
+SET(GRAMMAR_MULTILINE_COMMENT_CORE       "\".\"")
+
+CONFIGURE_FILE(${ARCADIA_ROOT}/ydb/library/yql/parser/proto_ast/org/antlr/v4/tool/templates/codegen/Cpp/Cpp.stg.in ${antlr_templates}/Cpp/Cpp.stg)
+CONFIGURE_FILE(${ARCADIA_ROOT}/ydb/library/yql/parser/proto_ast/org/antlr/v4/tool/templates/codegen/Cpp/Files.stg.in ${antlr_templates}/Cpp/Files.stg)
+
+IF(EXPORT_CMAKE)
+    MANUAL_GENERATION(${sql_grammar})
+ELSE()
+    CONFIGURE_FILE(${ARCADIA_ROOT}/ydb/library/yql/sql/v1/SQLv1Antlr4.g.in ${sql_grammar})
+ENDIF()
+
+NO_COMPILER_WARNINGS()
+
+ADDINCL(
+    GLOBAL contrib/libs/antlr4_cpp_runtime/src
+)
+
+INCLUDE(${ARCADIA_ROOT}/ydb/library/yql/parser/proto_ast/org/antlr/codegen/templates/ya.make.incl)
+
+RUN_ANTLR4(
+    ${sql_grammar}
+    -no-listener
+    -package NALPDefaultAntlr4
+    -lib .
+    -o ${antlr_output}
+    IN ${sql_grammar} ${antlr_templates}/Cpp/Cpp.stg ${antlr_templates}/Cpp/Files.stg
+    OUT SQLv1Antlr4Parser.cpp SQLv1Antlr4Lexer.cpp SQLv1Antlr4Parser.h SQLv1Antlr4Lexer.h
+    OUTPUT_INCLUDES
+    ${PROTOBUF_HEADER_PATH}/SQLv1Parser.pb.main.h
+    ${STG_INCLUDES}
+    CWD ${antlr_output}
+)
+
+END()
diff --git a/ydb/library/yql/parser/proto_ast/gen/v1_proto_antlr4/ya.make.gen b/ydb/library/yql/parser/proto_ast/gen/v1_proto_antlr4/ya.make.gen
new file mode 100644
index 000000000000..48df4c276040
--- /dev/null
+++ b/ydb/library/yql/parser/proto_ast/gen/v1_proto_antlr4/ya.make.gen
@@ -0,0 +1,38 @@
+PROTO_LIBRARY()
+
+IF (GEN_PROTO)
+    SET(antlr_output ${ARCADIA_BUILD_ROOT}/${MODDIR})
+    SET(antlr_templates ${antlr_output}/org/antlr/v4/tool/templates/codegen)
+    SET(sql_grammar ${antlr_output}/SQLv1Antlr4.g)
+
+    SET(ANTLR_PACKAGE_NAME NSQLv1Generated)
+
+    SET(GRAMMAR_STRING_CORE_SINGLE "\"~(['#BACKSLASH#]) | (BACKSLASH .)\"")
+    SET(GRAMMAR_STRING_CORE_DOUBLE "\"~([#DOUBLE_QUOTE##BACKSLASH#]) | (BACKSLASH .)\"")
+    SET(GRAMMAR_MULTILINE_COMMENT_CORE       "\".\"")
+
+    CONFIGURE_FILE(${ARCADIA_ROOT}/ydb/library/yql/parser/proto_ast/org/antlr/v4/tool/templates/codegen/Java/Java.stg.in ${antlr_templates}/Java/Java.stg)
+
+    IF(EXPORT_CMAKE)
+        MANUAL_GENERATION(${sql_grammar})
+    ELSE()
+        CONFIGURE_FILE(${ARCADIA_ROOT}/ydb/library/yql/sql/v1/SQLv1Antlr4.g.in ${sql_grammar})
+    ENDIF()
+
+    RUN_ANTLR4(
+        ${sql_grammar}
+        -no-listener
+        -lib .
+        -o ${antlr_output}
+        -Dlanguage=Java
+        IN ${sql_grammar} ${antlr_templates}/Java/Java.stg
+        OUT_NOAUTO SQLv1Parser.proto
+        CWD ${antlr_output}
+    )
+ENDIF()
+
+SRCS(SQLv1Parser.proto)
+
+EXCLUDE_TAGS(GO_PROTO JAVA_PROTO)
+
+END()
diff --git a/ydb/library/yql/parser/proto_ast/gen/v1_proto_split_antlr4/epilogue.cmake b/ydb/library/yql/parser/proto_ast/gen/v1_proto_split_antlr4/epilogue.cmake
new file mode 100644
index 000000000000..dc1496a45630
--- /dev/null
+++ b/ydb/library/yql/parser/proto_ast/gen/v1_proto_split_antlr4/epilogue.cmake
@@ -0,0 +1,9 @@
+set(GRAMMAR_STRING_CORE_SINGLE "~(['\\]) | (BACKSLASH .)")
+set(GRAMMAR_STRING_CORE_DOUBLE "~([\"\\]) | (BACKSLASH .)")
+set(GRAMMAR_MULTILINE_COMMENT_CORE       ".")
+
+configure_file(
+  ${CMAKE_SOURCE_DIR}/ydb/library/yql/sql/v1/SQLv1Antlr4.g.in
+  ${CMAKE_BINARY_DIR}/ydb/library/yql/parser/proto_ast/gen/v1_proto_split_antlr4/SQLv1Antlr4.g
+)
+
diff --git a/ydb/library/yql/parser/proto_ast/gen/v1_proto_split_antlr4/update.sh b/ydb/library/yql/parser/proto_ast/gen/v1_proto_split_antlr4/update.sh
new file mode 100755
index 000000000000..9e562ac57f2c
--- /dev/null
+++ b/ydb/library/yql/parser/proto_ast/gen/v1_proto_split_antlr4/update.sh
@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -eux
+cp ../v1_proto/ya.make.gen ../v1_proto/ya.make
+yag make ../v1_proto --add-result=".h" --add-result=".cc"
+rm ../v1_proto/ya.make
+python3 ../multiproto.py SQLv1Parser ../v1_proto .
+
diff --git a/ydb/library/yql/parser/proto_ast/gen/v1_proto_split_antlr4/ya.make b/ydb/library/yql/parser/proto_ast/gen/v1_proto_split_antlr4/ya.make
new file mode 100644
index 000000000000..f23e8a916cb3
--- /dev/null
+++ b/ydb/library/yql/parser/proto_ast/gen/v1_proto_split_antlr4/ya.make
@@ -0,0 +1,87 @@
+LIBRARY()
+
+SET(antlr_output ${ARCADIA_BUILD_ROOT}/${MODDIR})
+SET(antlr_templates ${antlr_output}/org/antlr/v4/tool/templates/codegen)
+SET(sql_grammar ${antlr_output}/SQLv1Antlr4.g)
+
+SET(ANTLR_PACKAGE_NAME NSQLv1Generated)
+
+SET(GRAMMAR_STRING_CORE_SINGLE "\"~(['#BACKSLASH#]) | (BACKSLASH .)\"")
+SET(GRAMMAR_STRING_CORE_DOUBLE "\"~([#DOUBLE_QUOTE##BACKSLASH#]) | (BACKSLASH .)\"")
+SET(GRAMMAR_MULTILINE_COMMENT_CORE       "\".\"")
+
+CONFIGURE_FILE(${ARCADIA_ROOT}/ydb/library/yql/parser/proto_ast/org/antlr/v4/tool/templates/codegen/Java/Java.stg.in ${antlr_templates}/Java/Java.stg)
+
+IF(EXPORT_CMAKE)
+    MANUAL_GENERATION(${sql_grammar})
+ELSE()
+    CONFIGURE_FILE(${ARCADIA_ROOT}/ydb/library/yql/sql/v1/SQLv1Antlr4.g.in ${sql_grammar})
+ENDIF()
+
+RUN_ANTLR4(
+    ${sql_grammar}
+    -lib .
+    -no-listener
+    -o ${antlr_output}
+    -Dlanguage=Java
+    IN ${sql_grammar} ${antlr_templates}/Java/Java.stg
+    OUT_NOAUTO SQLv1Antlr4Parser.proto
+    CWD ${antlr_output}
+)
+
+IF (USE_VANILLA_PROTOC)
+    SET(PROTOC_PATH contrib/tools/protoc_std)
+ELSE()
+    SET(PROTOC_PATH contrib/tools/protoc/bin)
+ENDIF()
+
+
+RUN_PROGRAM(
+    $PROTOC_PATH -I=$CURDIR -I=$ARCADIA_ROOT -I=$ARCADIA_BUILD_ROOT -I=$ARCADIA_ROOT/contrib/libs/protobuf/src
+    --cpp_out=$ARCADIA_BUILD_ROOT --cpp_styleguide_out=$ARCADIA_BUILD_ROOT
+    --plugin=protoc-gen-cpp_styleguide=contrib/tools/protoc/plugins/cpp_styleguide
+    SQLv1Antlr4Parser.proto
+    IN SQLv1Antlr4Parser.proto
+    TOOL contrib/tools/protoc/plugins/cpp_styleguide
+    OUT_NOAUTO SQLv1Antlr4Parser.pb.h SQLv1Antlr4Parser.pb.cc
+    CWD $ARCADIA_BUILD_ROOT
+)
+
+RUN_PYTHON3(
+    ${ARCADIA_ROOT}/ydb/library/yql/parser/proto_ast/gen/multiproto.py SQLv1Antlr4Parser
+    IN SQLv1Antlr4Parser.pb.h
+    IN SQLv1Antlr4Parser.pb.cc
+    OUT_NOAUTO 
+    SQLv1Antlr4Parser.pb.code0.cc
+    SQLv1Antlr4Parser.pb.code1.cc
+    SQLv1Antlr4Parser.pb.code2.cc
+    SQLv1Antlr4Parser.pb.code3.cc
+    SQLv1Antlr4Parser.pb.code4.cc
+    SQLv1Antlr4Parser.pb.code5.cc
+    SQLv1Antlr4Parser.pb.code6.cc
+    SQLv1Antlr4Parser.pb.code7.cc
+    SQLv1Antlr4Parser.pb.code8.cc
+    SQLv1Antlr4Parser.pb.code9.cc
+    SQLv1Antlr4Parser.pb.data.cc
+    SQLv1Antlr4Parser.pb.classes.h
+    SQLv1Antlr4Parser.pb.main.h
+    CWD $ARCADIA_BUILD_ROOT/ydb/library/yql/parser/proto_ast/gen/v1_proto_split_antlr4
+)
+
+PEERDIR(contrib/libs/protobuf)
+
+SRCS(
+    SQLv1Antlr4Parser.pb.code0.cc
+    SQLv1Antlr4Parser.pb.code1.cc
+    SQLv1Antlr4Parser.pb.code2.cc
+    SQLv1Antlr4Parser.pb.code3.cc
+    SQLv1Antlr4Parser.pb.code4.cc
+    SQLv1Antlr4Parser.pb.code5.cc
+    SQLv1Antlr4Parser.pb.code6.cc
+    SQLv1Antlr4Parser.pb.code7.cc
+    SQLv1Antlr4Parser.pb.code8.cc
+    SQLv1Antlr4Parser.pb.code9.cc
+    SQLv1Antlr4Parser.pb.data.cc
+)
+
+END()
diff --git a/ydb/library/yql/parser/proto_ast/gen/ya.make b/ydb/library/yql/parser/proto_ast/gen/ya.make
index 81d39789f9c8..347d52576ccf 100644
--- a/ydb/library/yql/parser/proto_ast/gen/ya.make
+++ b/ydb/library/yql/parser/proto_ast/gen/ya.make
@@ -4,4 +4,6 @@ RECURSE(
     v0_proto_split
     v1
     v1_proto_split
+    v1_antlr4
+    v1_proto_split_antlr4
 )
diff --git a/ydb/library/yql/parser/proto_ast/org/antlr/v4/tool/templates/codegen/Cpp/Cpp.stg.in b/ydb/library/yql/parser/proto_ast/org/antlr/v4/tool/templates/codegen/Cpp/Cpp.stg.in
new file mode 100644
index 000000000000..359d6c013cdc
--- /dev/null
+++ b/ydb/library/yql/parser/proto_ast/org/antlr/v4/tool/templates/codegen/Cpp/Cpp.stg.in
@@ -0,0 +1,1425 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2015 Dan McLaughlin, Mike Lischke
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *  3. The name of the author may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ *  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ *  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+import "Files.stg" // All file specific stuff.
+
+cppTypeInitMap ::= [
+    "int":"0",
+    "long":"0",
+    "float":"0.0f",
+    "double":"0.0",
+    "bool":"false",
+    "short":"0",
+    "char":"0",
+    default: "nullptr" // anything other than a primitive type is an object
+]
+
+LexerHeader(lexer, atn, actionFuncs, sempredFuncs, superClass = {antlr4::Lexer}) ::= <<
+<namedActions.context>
+
+class <file.exportMacro> <lexer.name> : public <superClass> {
+public:
+<if (lexer.tokens)>
+  enum {
+    <lexer.tokens: {k | TOKEN_<k> = <lexer.tokens.(k)>}; separator=", ", wrap, anchor>
+  };
+<endif>
+
+<if (lexer.escapedChannels)>
+  enum {
+    <lexer.escapedChannels: {k | <k> = <lexer.escapedChannels.(k)>}; separator=", ", wrap, anchor>
+  };
+<endif>
+
+<if (rest(lexer.escapedModeNames))>
+  enum {
+    <rest(lexer.escapedModeNames): {m | TOKEN_<m> = <i>}; separator=", ", wrap, anchor>
+  };
+<endif>
+
+  explicit <lexer.name>(antlr4::CharStream *input);
+
+  ~<lexer.name>() override;
+
+  <namedActions.members>
+
+  std::string getGrammarFileName() const override;
+
+  const std::vector\<std::string>& getRuleNames() const override;
+
+  const std::vector\<std::string>& getChannelNames() const override;
+
+  const std::vector\<std::string>& getModeNames() const override;
+
+  const antlr4::dfa::Vocabulary& getVocabulary() const override;
+
+  antlr4::atn::SerializedATNView getSerializedATN() const override;
+
+  const antlr4::atn::ATN& getATN() const override;
+
+  <if (actionFuncs)>
+  void action(antlr4::RuleContext *context, size_t ruleIndex, size_t actionIndex) override;
+  <endif>
+
+  <if (sempredFuncs)>
+  bool sempred(antlr4::RuleContext *_localctx, size_t ruleIndex, size_t predicateIndex) override;
+  <endif>
+
+  // By default the static state used to implement the lexer is lazily initialized during the first
+  // call to the constructor. You can call this function if you wish to initialize the static state
+  // ahead of time.
+  static void initialize();
+
+private:
+  <namedActions.declarations>
+
+  // Individual action functions triggered by action() above.
+  <actionFuncs.values; separator="\n">
+
+  // Individual semantic predicate functions triggered by sempred() above.
+  <sempredFuncs.values; separator="\n">
+
+  <atn>
+};
+>>
+
+Lexer(lexer, atn, actionFuncs, sempredFuncs, superClass = {Lexer}) ::= <<
+
+using namespace antlr4;
+
+namespace {
+
+struct <lexer.name; format = "cap">StaticData final {
+  <lexer.name; format = "cap">StaticData(std::vector\<std::string> ruleNames,
+                          std::vector\<std::string> channelNames,
+                          std::vector\<std::string> modeNames,
+                          std::vector\<std::string> literalNames,
+                          std::vector\<std::string> symbolicNames)
+      : ruleNames(std::move(ruleNames)), channelNames(std::move(channelNames)),
+        modeNames(std::move(modeNames)), literalNames(std::move(literalNames)),
+        symbolicNames(std::move(symbolicNames)),
+        vocabulary(this->literalNames, this->symbolicNames) {}
+
+  <lexer.name; format = "cap">StaticData(const <lexer.name; format = "cap">StaticData&) = delete;
+  <lexer.name; format = "cap">StaticData(<lexer.name; format = "cap">StaticData&&) = delete;
+  <lexer.name; format = "cap">StaticData& operator=(const <lexer.name; format = "cap">StaticData&) = delete;
+  <lexer.name; format = "cap">StaticData& operator=(<lexer.name; format = "cap">StaticData&&) = delete;
+
+  std::vector\<antlr4::dfa::DFA> decisionToDFA;
+  antlr4::atn::PredictionContextCache sharedContextCache;
+  const std::vector\<std::string> ruleNames;
+  const std::vector\<std::string> channelNames;
+  const std::vector\<std::string> modeNames;
+  const std::vector\<std::string> literalNames;
+  const std::vector\<std::string> symbolicNames;
+  const antlr4::dfa::Vocabulary vocabulary;
+  antlr4::atn::SerializedATNView serializedATN;
+  std::unique_ptr\<antlr4::atn::ATN> atn;
+};
+
+::antlr4::internal::OnceFlag <lexer.grammarName; format = "lower">LexerOnceFlag;
+<lexer.name; format = "cap">StaticData *<lexer.grammarName; format = "lower">LexerStaticData = nullptr;
+
+void <lexer.grammarName; format = "lower">LexerInitialize() {
+  assert(<lexer.grammarName; format = "lower">LexerStaticData == nullptr);
+  auto staticData = std::make_unique\<<lexer.name; format = "cap">StaticData>(
+    std::vector\<std::string>{
+      <lexer.ruleNames: {r | "<r>"}; separator = ", ", wrap, anchor>
+    },
+    std::vector\<std::string>{
+      "DEFAULT_TOKEN_CHANNEL", "HIDDEN"<if (lexer.channels)>, <lexer.channels: {c | "<c>"}; separator = ", ", wrap, anchor><endif>
+    },
+    std::vector\<std::string>{
+      <lexer.modes: {m | "<m>"}; separator = ", ", wrap, anchor>
+    },
+    std::vector\<std::string>{
+      <lexer.literalNames: {t | <t>}; null = "\"\"", separator = ", ", wrap, anchor>
+    },
+    std::vector\<std::string>{
+      <lexer.symbolicNames: {t | <t>}; null = "\"\"", separator = ", ", wrap, anchor>
+    }
+  );
+  <atn>
+  <lexer.grammarName; format = "lower">LexerStaticData = staticData.release();
+}
+
+}
+
+<lexer.name>::<lexer.name>(CharStream *input) : <superClass>(input) {
+  <lexer.name>::initialize();
+  _interpreter = new atn::LexerATNSimulator(this, *<lexer.grammarName; format = "lower">LexerStaticData->atn, <lexer.grammarName; format = "lower">LexerStaticData->decisionToDFA, <lexer.grammarName; format = "lower">LexerStaticData->sharedContextCache);
+}
+
+<lexer.name>::~<lexer.name>() {
+  delete _interpreter;
+}
+
+std::string <lexer.name>::getGrammarFileName() const {
+  return "<lexer.grammarFileName>";
+}
+
+const std::vector\<std::string>& <lexer.name>::getRuleNames() const {
+  return <lexer.grammarName; format = "lower">LexerStaticData->ruleNames;
+}
+
+const std::vector\<std::string>& <lexer.name>::getChannelNames() const {
+  return <lexer.grammarName; format = "lower">LexerStaticData->channelNames;
+}
+
+const std::vector\<std::string>& <lexer.name>::getModeNames() const {
+  return <lexer.grammarName; format = "lower">LexerStaticData->modeNames;
+}
+
+const dfa::Vocabulary& <lexer.name>::getVocabulary() const {
+  return <lexer.grammarName; format = "lower">LexerStaticData->vocabulary;
+}
+
+antlr4::atn::SerializedATNView <lexer.name>::getSerializedATN() const {
+  return <lexer.grammarName; format = "lower">LexerStaticData->serializedATN;
+}
+
+const atn::ATN& <lexer.name>::getATN() const {
+  return *<lexer.grammarName; format = "lower">LexerStaticData->atn;
+}
+
+<namedActions.definitions>
+
+<if (actionFuncs)>
+void <lexer.name>::action(RuleContext *context, size_t ruleIndex, size_t actionIndex) {
+  switch (ruleIndex) {
+    <lexer.actionFuncs.values: {f | case <f.ruleIndex>: <f.name>Action(antlrcpp::downCast\<<f.ctxType> *>(context), actionIndex); break;}; separator="\n">
+
+  default:
+    break;
+  }
+}
+<endif>
+
+<if (sempredFuncs)>
+bool <lexer.name>::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) {
+  switch (ruleIndex) {
+    <lexer.sempredFuncs.values: {f | case <f.ruleIndex>: return <f.name>Sempred(antlrcpp::downCast\<<f.ctxType> *>(context), predicateIndex);}; separator="\n">
+
+  default:
+    break;
+  }
+  return true;
+}
+<endif>
+
+<actionFuncs.values; separator="\n">
+
+<sempredFuncs.values; separator="\n">
+
+void <lexer.name>::initialize() {
+  ::antlr4::internal::call_once(<lexer.grammarName; format = "lower">LexerOnceFlag, <lexer.grammarName; format = "lower">LexerInitialize);
+}
+>>
+
+RuleActionFunctionHeader(r, actions) ::= <<
+void <r.name>Action(<r.ctxType> *context, size_t actionIndex);
+>>
+
+RuleActionFunction(r, actions) ::= <<
+void <r.factory.grammar.name>::<r.name>Action(<r.ctxType> *context, size_t actionIndex) {
+  switch (actionIndex) {
+    <actions: {index | case <index>: <actions.(index)> break;}; separator="\n">
+
+  default:
+    break;
+  }
+}
+
+>>
+
+RuleSempredFunctionHeader(r, actions) ::= <<
+bool <r.name>Sempred(<r.ctxType> *_localctx, size_t predicateIndex);
+>>
+
+RuleSempredFunction(r, actions) ::= <<
+<! Called for both lexer and parser. But only one of them is actually available. Testing for the parser directly
+   generates a warning, however. So do the check via the factory instead. !>
+bool <if (r.factory.g.lexer)><lexer.name><else><parser.name><endif>::<r.name>Sempred(<r.ctxType> *_localctx, size_t predicateIndex) {
+  switch (predicateIndex) {
+    <actions: {index | case <index>: return <actions.(index)>}; separator=";\n">;
+
+  default:
+    break;
+  }
+  return true;
+}
+
+>>
+
+//--------------------------------------------------------------------------------------------------
+
+ParserHeader(parser, funcs, atn, sempredFuncs, superClass = {antlr4::Parser}) ::= <<
+<namedActions.context>
+
+class <file.exportMacro> <parser.name> : public <superClass> {
+public:
+  typedef google::protobuf::Message* RuleReturnType; 
+
+<if (parser.tokens)>
+  enum {
+    <parser.tokens: {k | TOKEN_<k> = <parser.tokens.(k)>}; separator=", ", wrap, anchor>
+  };
+<endif>
+
+<if (parser.rules)>
+  enum {
+    <parser.rules: {r | Rule<r.name; format="cap"> = <r.index>}; separator=", ", wrap, anchor>
+  };
+<endif>
+
+  explicit <parser.name>(antlr4::TokenStream *input);
+
+  <parser.name>(antlr4::TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options);
+  <parser.name>(antlr4::TokenStream *input, google::protobuf::Arena* arena);
+  RuleReturnType Parse(NProtoAST::IErrorCollector* errors = 0);
+
+  ~<parser.name>() override;
+
+  std::string getGrammarFileName() const override;
+
+  const antlr4::atn::ATN& getATN() const override;
+
+  const std::vector\<std::string>& getRuleNames() const override;
+
+  const antlr4::dfa::Vocabulary& getVocabulary() const override;
+
+  antlr4::atn::SerializedATNView getSerializedATN() const override;
+
+  <namedActions.members>
+
+  <parser.funcs: {f | class <f.name; format = "cap">Context;};  separator = "\n"> <! Forward declare context classes. !>
+
+  <funcs; separator = "\n">
+
+  <if (sempredFuncs)>
+  bool sempred(antlr4::RuleContext *_localctx, size_t ruleIndex, size_t predicateIndex) override;
+
+  <sempredFuncs.values; separator = "\n">
+  <endif>
+
+  // By default the static state used to implement the parser is lazily initialized during the first
+  // call to the constructor. You can call this function if you wish to initialize the static state
+  // ahead of time.
+  static void initialize();
+  bool error = false;
+  static const size_t TOKEN_EOF = std::numeric_limits\<size_t>::max();
+
+private:
+  google::protobuf::Arena* Arena = nullptr;
+  <namedActions.declarations>
+};
+>>
+
+Parser(parser, funcs, atn, sempredFuncs, superClass = {Parser}) ::= <<
+
+using namespace antlr4;
+
+namespace {
+
+struct <parser.name; format = "cap">StaticData final {
+  <parser.name; format = "cap">StaticData(std::vector\<std::string> ruleNames,
+                        std::vector\<std::string> literalNames,
+                        std::vector\<std::string> symbolicNames)
+      : ruleNames(std::move(ruleNames)), literalNames(std::move(literalNames)),
+        symbolicNames(std::move(symbolicNames)),
+        vocabulary(this->literalNames, this->symbolicNames) {}
+
+  <parser.name; format = "cap">StaticData(const <parser.name; format = "cap">StaticData&) = delete;
+  <parser.name; format = "cap">StaticData(<parser.name; format = "cap">StaticData&&) = delete;
+  <parser.name; format = "cap">StaticData& operator=(const <parser.name; format = "cap">StaticData&) = delete;
+  <parser.name; format = "cap">StaticData& operator=(<parser.name; format = "cap">StaticData&&) = delete;
+
+  std::vector\<antlr4::dfa::DFA> decisionToDFA;
+  antlr4::atn::PredictionContextCache sharedContextCache;
+  const std::vector\<std::string> ruleNames;
+  const std::vector\<std::string> literalNames;
+  const std::vector\<std::string> symbolicNames;
+  const antlr4::dfa::Vocabulary vocabulary;
+  antlr4::atn::SerializedATNView serializedATN;
+  std::unique_ptr\<antlr4::atn::ATN> atn;
+};
+
+::antlr4::internal::OnceFlag <parser.grammarName; format = "lower">ParserOnceFlag;
+<parser.name; format = "cap">StaticData *<parser.grammarName; format = "lower">ParserStaticData = nullptr;
+
+void <parser.grammarName; format = "lower">ParserInitialize() {
+  assert(<parser.grammarName; format = "lower">ParserStaticData == nullptr);
+  auto staticData = std::make_unique\<<parser.name; format = "cap">StaticData>(
+    std::vector\<std::string>{
+      <parser.ruleNames: {r | "<r>"}; separator = ", ", wrap, anchor>
+    },
+    std::vector\<std::string>{
+      <parser.literalNames: {t | <t>}; null = "\"\"", separator = ", ", wrap, anchor>
+    },
+    std::vector\<std::string>{
+      <parser.symbolicNames: {t | <t>}; null = "\"\"", separator = ", ", wrap, anchor>
+    }
+  );
+  <atn>
+  <parser.grammarName; format = "lower">ParserStaticData = staticData.release();
+}
+
+}
+
+<parser.name>::<parser.name>(TokenStream *input) : <parser.name>(input, antlr4::atn::ParserATNSimulatorOptions()) {}
+
+<parser.name>::<parser.name>(antlr4::TokenStream *input, google::protobuf::Arena* arena) : <parser.name>(input, antlr4::atn::ParserATNSimulatorOptions()) {
+  Arena = arena;
+}
+
+<parser.name>::<parser.name>(TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options) : <superClass>(input) {
+  <parser.name>::initialize();
+  _interpreter = new atn::ParserATNSimulator(this, *<parser.grammarName; format = "lower">ParserStaticData->atn, <parser.grammarName; format = "lower">ParserStaticData->decisionToDFA, <parser.grammarName; format = "lower">ParserStaticData->sharedContextCache, options);
+}
+
+<parser.name>::RuleReturnType <parser.name>::Parse(NProtoAST::IErrorCollector* errors) {
+  try {
+    RuleReturnType root(<parser.name>::<first(parser.funcs).name>());
+    if (!error && root) {
+      auto ast = google::protobuf::Arena::CreateMessage\<@ANTLR_PACKAGE_NAME@::TSQLv1ParserAST>(Arena);
+      Y_ASSERT(dynamic_cast\<@ANTLR_PACKAGE_NAME@::TRule_<first(parser.funcs).name>* >(root));
+      ast->unsafe_arena_set_allocated_rule_<first(parser.funcs).name>(static_cast\<@ANTLR_PACKAGE_NAME@::TRule_<first(parser.funcs).name>* >(root));
+      return ast;
+    \}
+    return nullptr;
+  \} catch (RecognitionException &err) {
+    return nullptr;
+  \}
+  return nullptr;
+}
+
+<parser.name>::~<parser.name>() {
+  delete _interpreter;
+}
+
+const atn::ATN& <parser.name>::getATN() const {
+  return *<parser.grammarName; format = "lower">ParserStaticData->atn;
+}
+
+std::string <parser.name>::getGrammarFileName() const {
+  return "<parser.grammarFileName>";
+}
+
+const std::vector\<std::string>& <parser.name>::getRuleNames() const {
+  return <parser.grammarName; format = "lower">ParserStaticData->ruleNames;
+}
+
+const dfa::Vocabulary& <parser.name>::getVocabulary() const {
+  return <parser.grammarName; format = "lower">ParserStaticData->vocabulary;
+}
+
+antlr4::atn::SerializedATNView <parser.name>::getSerializedATN() const {
+  return <parser.grammarName; format = "lower">ParserStaticData->serializedATN;
+}
+
+<namedActions.definitions>
+
+<funcs; separator = "\n\n">
+
+<if (sempredFuncs)>
+bool <parser.name>::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) {
+  switch (ruleIndex) {
+  <parser.sempredFuncs.values: {f |
+  case <f.ruleIndex>: return <f.name>Sempred(antlrcpp::downCast\<<f.ctxType> *>(context), predicateIndex);}; separator="\n">
+
+  default:
+    break;
+  }
+  return true;
+}
+
+<sempredFuncs.values; separator="\n"><endif>
+
+void <parser.name>::initialize() {
+  ::antlr4::internal::call_once(<parser.grammarName; format = "lower">ParserOnceFlag, <parser.grammarName; format = "lower">ParserInitialize);
+}
+>>
+
+SerializedATNHeader(model) ::= <<
+>>
+
+SerializedATN(model) ::= <<
+static const int32_t serializedATNSegment[] = {
+	<model.serialized: {s | <s>}; separator=",", wrap>
+};
+staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0]));
+
+antlr4::atn::ATNDeserializer deserializer;
+staticData->atn = deserializer.deserialize(staticData->serializedATN);
+
+const size_t count = staticData->atn->getNumberOfDecisions();
+staticData->decisionToDFA.reserve(count);
+for (size_t i = 0; i \< count; i++) { <! Rework class ATN to allow standard iterations. !>
+  staticData->decisionToDFA.emplace_back(staticData->atn->getDecisionState(i), i);
+}
+>>
+
+RuleFunctionHeader(currentRule, args, code, locals, ruleCtx, altLabelCtxs, namedActions, finallyAction, postamble, exceptions) ::= <<
+<ruleCtx>
+<! TODO: untested !><if (altLabelCtxs)><altLabelCtxs: {l | <altLabelCtxs.(l)>}; separator="\n"><endif>
+RuleReturnType <currentRule.escapedName>(<args; separator=",">);
+
+>>
+
+RuleFunction(currentRule, args, code, locals, ruleCtx, altLabelCtxs, namedActions, finallyAction, postamble, exceptions) ::= <<
+<ruleCtx>
+<! TODO: untested !><altLabelCtxs: {l | <altLabelCtxs.(l)>}; separator = "\n">
+<parser.name>::RuleReturnType <parser.name>::<currentRule.escapedName>(<args; separator=",">) {
+  <currentRule.ctxType> *_localctx = _tracker.createInstance\<<currentRule.ctxType>\>(_ctx, getState()<currentRule.args:{a | , <a.escapedName>}>);
+  // proto stuff
+  @ANTLR_PACKAGE_NAME@::TRule_<currentRule.name>* retval = google::protobuf::Arena::CreateMessage\<@ANTLR_PACKAGE_NAME@::TRule_<currentRule.name>\>(Arena);
+  auto parent = retval;
+  std::string invoked_stmt;
+  // proto end
+  enterRule(_localctx, <currentRule.startState>, <parser.name>::Rule<currentRule.name; format = "cap">);
+  <namedActions.init>
+  <locals; separator = "\n">
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+  <finallyAction>
+    exitRule();
+  });
+  try {
+<! TODO: untested !><if (currentRule.hasLookaheadBlock)>
+    size_t alt;
+    <endif>
+    <if((!rest(code))&&first(code).alts&&rest(first(code).alts))>
+    <code; separator="\n">
+    <else>
+    <code:{e | <element(e, i)>}; separator="\n">
+    if (parent) {
+      parent->SetDescr("<currentRule.name>");
+    }
+    <endif>
+<! TODO: untested !>   <postamble; separator = "\n">
+    <namedActions.after>
+  }
+  <if (exceptions)>
+  <exceptions; separator="\n">
+  <else>
+  catch (RecognitionException &e) {
+    _errHandler->reportError(this, e);
+   // _localctx->exception = std::current_exception();
+   //_errHandler->recover(this, _localctx->exception);
+   throw;
+  }
+  <endif>
+  <if((!rest(code))&&first(code).alts&&rest(first(code).alts))>
+  if (retval && (!parent || !retval->Alt_case())) {
+    retval = nullptr;
+  }
+  <else>
+  if (!parent) {
+    retval = nullptr;
+  }
+  <endif>
+
+  return retval;
+}
+>>
+
+LeftRecursiveRuleFunctionHeader(currentRule, args, code, locals, ruleCtx, altLabelCtxs, namedActions, finallyAction, postamble) ::= <<
+<ruleCtx>
+<! TODO: untested !><altLabelCtxs: {l | <altLabelCtxs.(l)>}; separator="\n">
+<currentRule.ctxType>* <currentRule.escapedName>(<currentRule.args; separator = ", ">);
+<currentRule.ctxType>* <currentRule.escapedName>(int precedence<currentRule.args: {a | , <a>}>);
+>>
+
+LeftRecursiveRuleFunction(currentRule, args, code, locals, ruleCtx, altLabelCtxs, namedActions, finallyAction, postamble) ::= <<
+<ruleCtx>
+<altLabelCtxs: {l | <altLabelCtxs.(l)>}; separator="\n">
+
+<parser.name>::<currentRule.ctxType>* <parser.name>::<currentRule.escapedName>(<currentRule.args; separator=", ">) {
+<! TODO: currentRule.args untested !>   return <currentRule.escapedName>(0<currentRule.args: {a | , <a.escapedName>}>);
+}
+
+<parser.name>::<currentRule.ctxType>* <parser.name>::<currentRule.escapedName>(int precedence<currentRule.args:{a | , <a>}>) {
+  ParserRuleContext *parentContext = _ctx;
+  size_t parentState = getState();
+  // proto stuff
+  @ANTLR_PACKAGE_NAME@::TRule_<currentRule.name>* retval = google::protobuf::Arena::CreateMessage\<@ANTLR_PACKAGE_NAME@::TRule_<currentRule.name>\>(Arena);
+  auto parent = retval;
+  std::string invoked_stmt;
+  // proto end
+  <parser.name>::<currentRule.ctxType> *_localctx = _tracker.createInstance\<<currentRule.ctxType>\>(_ctx, parentState<currentRule.args: {a | , <a.escapedName>}>);
+  <parser.name>::<currentRule.ctxType> *previousContext = _localctx;
+  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
+  size_t startState = <currentRule.startState>;
+  enterRecursionRule(_localctx, <currentRule.startState>, <parser.name>::Rule<currentRule.name; format = "cap">, precedence);
+
+    <namedActions.init>
+<! TODO: untested !>    <locals; separator = "\n">
+
+#if __cplusplus > 201703L
+  auto onExit = finally([=, this] {
+#else
+  auto onExit = finally([=] {
+#endif
+  <if (finallyAction)><finallyAction><endif>
+    unrollRecursionContexts(parentContext);
+  });
+  try {
+    <if (currentRule.hasLookaheadBlock)>size_t alt;<endif>
+    <if(rest(code))>
+    <code:{e | <element(e, i)>}; separator="\n">
+    <else>
+    <if(first(code).alts)>
+    <if(rest(first(code).alts))>
+    <code; separator="\n">
+    <else>
+    <code:{e | <element(e, i)>}; separator="\n">
+    <endif>
+    <else>
+    <code; separator="\n">
+    <endif>
+    <endif>
+<! TODO: untested !><postamble; separator = "\n">
+    <namedActions.after>
+  }
+  catch (RecognitionException &e) {
+    // _errHandler->reportError(this, e);
+    // _localctx->exception = std::current_exception();
+    //_errHandler->recover(this, _localctx->exception);
+    throw;
+  }
+  <if(rest(code))>
+  if (!parent) {
+    retval = nullptr;
+  }
+  <else>
+  <if(first(code).alts)>
+  <if(rest(first(code).alts))>
+  if (!parent || !retval->Alt_case()) {
+    retval = nullptr;
+  }
+  <else>
+  if (!parent) {
+    retval = nullptr;
+  }
+  <endif>
+  <else>
+  if (!parent) {
+    retval = nullptr;
+  }
+  <endif>
+  <endif>
+  return retval;
+}
+>>
+
+StructDeclHeader(struct, ctorAttrs, attrs, getters, dispatchMethods, interfaces, extensionMembers) ::= <<
+class <file.exportMacro> <struct.escapedName> : public <if (contextSuperClass)><contextSuperClass><else>antlr4::ParserRuleContext<endif><if(interfaces)>, <interfaces; separator=", "><endif> {
+public:
+  <attrs: {a | <a>;}; separator = "\n">
+  <if (ctorAttrs)><struct.escapedName>(antlr4::ParserRuleContext *parent, size_t invokingState);<endif>
+  <struct.escapedName>(antlr4::ParserRuleContext *parent, size_t invokingState<ctorAttrs: {a | , <a>}>);
+<if (struct.provideCopyFrom)> <! don't need copy unless we have subclasses !>
+  <struct.escapedName>() = default;
+  void copyFrom(<struct.escapedName> *context);
+  using antlr4::ParserRuleContext::copyFrom;
+<endif>
+
+  virtual size_t getRuleIndex() const override;
+  <getters: {g | <g>}; separator = "\n">
+
+  <dispatchMethods; separator = "\n">
+<! TODO: untested !> <extensionMembers; separator = "\n">
+};
+
+>>
+
+element(e, elemId) ::= <<
+<e>
+>>
+
+StructDecl(struct, ctorAttrs, attrs, getters, dispatchMethods, interfaces, extensionMembers) ::= <<
+//----------------- <struct.escapedName> ------------------------------------------------------------------
+
+<if (ctorAttrs)>
+<parser.name>::<struct.escapedName>::<struct.escapedName>(ParserRuleContext *parent, size_t invokingState)
+  : <if (contextSuperClass)><contextSuperClass><else>ParserRuleContext<endif>(parent, invokingState) {
+}
+<endif>
+
+<parser.name>::<struct.escapedName>::<struct.escapedName>(ParserRuleContext *parent, size_t invokingState<ctorAttrs: {a | , <a>}>)
+  : <if (contextSuperClass)><contextSuperClass><else>ParserRuleContext<endif>(parent, invokingState) {
+  <struct.ctorAttrs: {a | this-><a.escapedName> = <a.escapedName>;}; separator="\n">
+}
+
+<getters: {g | <g>}; separator = "\n">
+
+size_t <parser.name>::<struct.escapedName>::getRuleIndex() const {
+  return <parser.name>::Rule<struct.derivedFromName; format = "cap">;
+}
+
+<if (struct.provideCopyFrom)>
+void <parser.name>::<struct.escapedName>::copyFrom(<struct.escapedName> *ctx) {
+  <if (contextSuperClass)><contextSuperClass><else>ParserRuleContext<endif>::copyFrom(ctx);
+  <struct.attrs: {a | this-><a.escapedName> = ctx-><a.escapedName>;}; separator = "\n">
+}
+<endif>
+<dispatchMethods; separator = "\n\n">
+<! TODO: untested !><extensionMembers; separator = "\n\n">
+
+>>
+
+AltLabelStructDeclHeader(struct, attrs, getters, dispatchMethods) ::= <<
+class <file.exportMacro> <struct.escapedName> : public <currentRule.name; format = "cap">Context {
+public:
+  <struct.escapedName>(<currentRule.name; format = "cap">Context *ctx);
+
+  <if (attrs)><attrs: {a | <a>;}; separator = "\n"><endif>
+  <getters: {g | <g>}; separator = "\n">
+  <dispatchMethods; separator = "\n">
+};
+
+>>
+
+AltLabelStructDecl(struct, attrs, getters, dispatchMethods) ::= <<
+//----------------- <struct.escapedName> ------------------------------------------------------------------
+
+<! TODO: untested !><if (attrs)><attrs: {a | <a>}; separator = "\n"><endif>
+<getters: {g | <g>}; separator = "\n">
+<parser.name>::<struct.escapedName>::<struct.escapedName>(<currentRule.name; format = "cap">Context *ctx) { copyFrom(ctx); }
+
+<dispatchMethods; separator="\n">
+>>
+
+
+CodeBlockForOuterMostAltHeader(currentOuterMostAltCodeBlock, locals, preamble, ops) ::= "<! Required to exist, but unused. !>"
+CodeBlockForOuterMostAlt(currentOuterMostAltCodeBlock, locals, preamble, ops) ::= <<
+<if (currentOuterMostAltCodeBlock.altLabel)>
+_localctx = _tracker.createInstance\<<parser.name>::<currentOuterMostAltCodeBlock.altLabel; format = "cap">Context>(_localctx);
+<endif>
+enterOuterAlt(_localctx, <currentOuterMostAltCodeBlock.alt.altNum>);
+<CodeBlockForAlt(currentAltCodeBlock = currentOuterMostAltCodeBlock, ...)>
+>>
+
+CodeBlockForAltHeader(currentAltCodeBlock, locals, preamble, ops) ::= "<! Required to exist, but unused. !>"
+CodeBlockForAlt(currentAltCodeBlock, locals, preamble, ops) ::= <<
+<! TODO: untested !><locals; separator = "\n">
+<! TODO: untested !><preamble; separator = "\n">
+<ops:{e | <element(e, i)>}; separator="\n">
+>>
+
+LL1AltBlockHeader(choice, preamble, alts, error) ::= "<! Required to exist, but unused. !>"
+LL1AltBlock(choice, preamble, alts, error) ::= <<
+{ // LL1AltBlock
+  setState(<choice.stateNumber>);
+  _errHandler->sync(this);
+  <! TODO: untested !><if (choice.label)>LL1AltBlock(choice, preamble, alts, error) <labelref(choice.label)> = _input->LT(1);<endif>
+  <preamble; separator="\n">
+  switch (_input->LA(1)) {
+    <choice.altLook, alts: {look, alt | <cases(tokens = look)> {
+    <if(alt)>
+    // LL1AltBlock protobuf stuff
+    auto &global_parent = parent;
+    auto parent = global_parent-><if(elemId)>MutableBlock<elemId>()-><endif><if(rest(alts))>MutableAlt<if(!elemId)>_<currentRule.name><endif><i>()<endif>;
+    <if(elemId)><if(!rest(alts))>
+    global_parent->MutableBlock<elemId>()->SetDescr("<currentRule.name>");
+    <endif><endif>
+    // protobuf end
+    <endif>
+    <alt>
+    <if(!elemId)><if(rest(alts))>
+    global_parent->MutableAlt_<currentRule.name><i>()->SetDescr(invoked_stmt.c_str());
+    <endif><endif>
+    <if(elemId)>
+    // LL1AltBlock protobuf stuff
+    if (!parent) {
+      global_parent->ClearBlock<elemId>();
+      global_parent = nullptr;
+    \}
+    // protobuf end
+    <endif>
+    break;
+  \}
+  }; separator = "\n">
+  default:
+    <error>
+  }
+}
+>>
+
+LL1OptionalBlockHeader(choice, alts, error) ::= "<! Required but unused. !>"
+LL1OptionalBlock(choice, alts, error) ::= <<
+{ // LL1OptionalBlock
+  setState(<choice.stateNumber>);
+  _errHandler->sync(this);
+  switch (_input->LA(1)) {
+    <choice.altLook, alts: {look, alt | <cases(tokens = look)> {
+    <if(alt)>
+    // LL1OptionalBlock protobuf stuff
+    auto &global_parent = parent;
+    auto parent = global_parent->MutableBlock<elemId>()<if(rest(alts))>->MutableAlt<i>()<endif>;
+    <if(!rest(alts))>
+    global_parent->MutableBlock<elemId>()->SetDescr("<currentRule.name>");
+    <endif>
+    // protobuf end
+    <endif>
+    <alt>
+    <if(alt)>
+    // LL1OptionalBlock protobuf stuff
+    if (!parent) {
+      global_parent->ClearBlock<elemId>();
+      global_parent = nullptr;
+    \}
+    // protobuf end
+    <endif>
+    break;
+  \}
+  }; separator="\n">
+  default:
+    break;
+  \}
+}
+>>
+
+LL1OptionalBlockSingleAltHeader(choice, expr, alts, preamble, error, followExpr) ::= "<! Required but unused. !>"
+LL1OptionalBlockSingleAlt(choice, expr, alts, preamble, error, followExpr) ::= <<
+setState(<choice.stateNumber>);
+_errHandler->sync(this);
+
+<preamble; separator = "\n">
+if (<expr>) {
+  // LL1OptionalBlockSingleAlt protobuf stuff
+  auto &global_parent = parent;
+  auto parent = global_parent->MutableBlock<elemId>();
+  global_parent->MutableBlock<elemId>()->SetDescr("<currentRule.name>");
+  // protobuf end
+  <alts; separator = "\n">
+  // LL1OptionalBlockSingleAlt protobuf stuff
+  if (!parent) {
+    global_parent->ClearBlock<elemId>();
+    global_parent = nullptr;
+  \}
+  // protobuf end
+}
+>>
+
+LL1StarBlockSingleAltHeader(choice, loopExpr, alts, preamble, iteration) ::= "<! Required but unused. !>"
+LL1StarBlockSingleAlt(choice, loopExpr, alts, preamble, iteration) ::= <<
+{ // LL1StarBlockSingleAlt
+  setState(<choice.stateNumber>);
+  _errHandler->sync(this);
+  <preamble; separator="\n">
+  // LL1StarBlockSingleAlt protobuf stuff
+  auto global_parent = parent;
+  // protobuf end
+  while (<loopExpr>) {
+    // LL1StarBlockSingleAlt protobuf stuff
+    auto parent = global_parent->AddBlock<elemId>();
+    // protobuf end
+    <alts; separator="\n">
+    // LL1StarBlockSingleAlt protobuf stuff
+    if (!parent) {
+      global_parent->MutableBlock<elemId>()->RemoveLast();
+    \}
+    // protobuf end
+    setState(<choice.loopBackStateNumber>);
+    _errHandler->sync(this);
+    <iteration>
+  }
+}
+>>
+
+LL1PlusBlockSingleAltHeader(choice, loopExpr, alts, preamble, iteration) ::= "<! Required but unused. !>"
+LL1PlusBlockSingleAlt(choice, loopExpr, alts, preamble, iteration) ::= <<
+{
+  setState(<choice.blockStartStateNumber>); <! alt block decision !>
+  _errHandler->sync(this);
+  <preamble; separator="\n">
+  // LL1PlusBlockSingleAlt protobuf stuff
+  auto global_parent = parent;
+  // protobuf end
+  do {
+    // LL1StarBlockSingleAlt protobuf stuff
+    auto parent = global_parent->AddBlock<elemId>();
+    // protobuf end
+    <alts; separator="\n">
+    // LL1StarBlockSingleAlt protobuf stuff
+    if (!parent) {
+      global_parent->MutableBlock<elemId>()->RemoveLast();
+    \}
+    // protobuf end
+    setState(<choice.stateNumber>); <! loopback/exit decision !>
+    _errHandler->sync(this);
+    <iteration>
+  } while (<loopExpr>);
+  Y_ABORT_UNLESS(global_parent, "parentBlock is null");
+  if (!global_parent->Block<elemId>Size()) {
+  parent = nullptr;
+  \}
+}
+>>
+
+// LL(*) stuff
+
+AltBlockHeader(choice, preamble, alts, error) ::= "<! Unused but must be present. !>"
+AltBlock(choice, preamble, alts, error) ::= <<
+{ // AltBlock
+  setState(<choice.stateNumber>);
+  _errHandler->sync(this);
+  <! TODO: untested !><if (choice.label)><labelref(choice.label)> = _input->LT(1);<endif>
+  <! TODO: untested !><preamble; separator = "\n">
+  switch (getInterpreter\<atn::ParserATNSimulator>()->adaptivePredict(_input, <choice.decision>, _ctx)) {
+  <alts: {alt | case <i>: {
+    <if(alt)>
+    // AltBlock protobuf stuff
+    auto &global_parent = parent;
+    auto parent = global_parent-><if(elemId)>MutableBlock<elemId>()-><endif><if(rest(alts))>MutableAlt<if(!elemId)>_<currentRule.name><endif><i>()<endif>;
+    <if(elemId)><if(!rest(alts))>
+    global_parent->MutableBlock<elemId>()->SetDescr("<currentRule.name>");
+    <endif><endif>
+    // protobuf end
+    <endif>
+    <alt>
+    <if(!elemId)><if(rest(alts))>
+    global_parent->MutableAlt_<currentRule.name><i>()->SetDescr(invoked_stmt.c_str());
+    <endif><endif>
+    <if(elemId)>
+    // AltBlock protobuf stuff
+    if (!parent) {
+      global_parent->ClearBlock<elemId>();
+      global_parent = nullptr;
+    \}
+    // protobuf end
+    <endif>
+    break;
+  \}
+  }; separator="\n">
+  default:
+    break;
+  }
+}
+>>
+
+OptionalBlockHeader(choice, alts, error) ::= "<! Unused but must be present. !>"
+OptionalBlock(choice, alts, error) ::= <<
+{ // OptionalBlock
+  setState(<choice.stateNumber>);
+  _errHandler->sync(this);
+  switch (getInterpreter\<atn::ParserATNSimulator>()->adaptivePredict(_input, <choice.decision>, _ctx)) {
+  <alts: {alt | case <i><if (!choice.ast.greedy)> + 1<endif>: {
+    <if(alt)>
+    // OptionalBlock protobuf stuff
+    auto &global_parent = parent;
+    auto parent = global_parent->MutableBlock<elemId>()<if(rest(alts))>->MutableAlt<i>()<endif>;
+    <if(!rest(alts))>
+    global_parent->MutableBlock<elemId>()->SetDescr("<currentRule.name>");
+    <endif>
+    // protobuf end
+    <endif>
+    <alt>
+    <if(alt)>
+    // LL1OptionalBlock protobuf stuff
+    if (!parent) {
+      global_parent->ClearBlock<elemId>();
+      global_parent = nullptr;
+    \}
+    // protobuf end
+    <endif>
+    break;
+  \}
+  }; separator = "\n">
+  default:
+    break;
+  }
+}
+>>
+
+StarBlockHeader(choice, alts, sync, iteration) ::= "<! Unused but must be present. !>"
+StarBlock(choice, alts, sync, iteration) ::= <<
+{ // StarBlock
+  setState(<choice.stateNumber>);
+  _errHandler->sync(this);
+  alt = getInterpreter\<atn::ParserATNSimulator>()->adaptivePredict(_input, <choice.decision>, _ctx);
+  // StarBlock protobuf stuff
+  auto& global_parent = parent;
+  // protobuf end
+  while (alt != <choice.exitAlt> && alt != atn::ATN::INVALID_ALT_NUMBER) {
+    if (alt == 1<if(!choice.ast.greedy)> + 1<endif>) {
+      <iteration>
+      // StarBlock protobuf stuff
+      auto parent = global_parent->AddBlock<elemId>();
+      // protobuf end
+      <alts> <! should only be one !>
+      // StarBlock protobuf stuff
+      if (!parent) {
+        global_parent->MutableBlock<elemId>()->RemoveLast();
+      }
+      // protobuf end
+    }
+    setState(<choice.loopBackStateNumber>);
+    _errHandler->sync(this);
+    alt = getInterpreter\<atn::ParserATNSimulator>()->adaptivePredict(_input, <choice.decision>, _ctx);
+  }
+}
+>>
+
+PlusBlockHeader(choice, alts, error) ::= "<! Required to exist, but unused. !>"
+PlusBlock(choice, alts, error) ::= <<
+{ // PlusBlock
+  setState(<choice.blockStartStateNumber>); <! alt block decision !>
+  _errHandler->sync(this);
+  alt = 1<if(!choice.ast.greedy)> + 1<endif>;
+  // PlusBlock protobuf stuff
+  auto global_parent = parent;
+  // protobuf end
+  do {
+    switch (alt) {
+      <alts: {alt | case <i><if (!choice.ast.greedy)> + 1<endif>: {
+        <if(rest(alts))>
+        // OptionalBlock protobuf stuff
+        auto parent = global_parent->AddBlock<elemId>()->MutableAlt<i>();
+        // protobuf end
+        <else>
+        auto parent = global_parent->AddBlock<elemId>();
+        <endif>
+        <alt>
+        if (!parent) {
+          global_parent->MutableBlock<elemId>()->RemoveLast();
+        \}
+        break;
+      \}
+  }; separator="\n">
+    default:
+      <error>
+    }
+    setState(<choice.loopBackStateNumber>); <! loopback/exit decision !>
+    _errHandler->sync(this);
+    alt = getInterpreter\<atn::ParserATNSimulator>()->adaptivePredict(_input, <choice.decision>, _ctx);
+  } while (alt != <choice.exitAlt> && alt != atn::ATN::INVALID_ALT_NUMBER);
+  Y_ABORT_UNLESS(global_parent, "parentBlock is null");
+  if (!global_parent->Block<elemId>Size()) {
+    parent = nullptr;
+  \}
+}
+>>
+
+Sync(s) ::= "Sync(s) sync(<s.expecting.name>);"
+
+ThrowNoViableAltHeader(t) ::= "<! Unused but must be present. !>"
+ThrowNoViableAlt(t) ::= "throw NoViableAltException(this);"
+
+TestSetInlineHeader(s) ::= "<! Required but unused. !>"
+TestSetInline(s) ::= <<
+<s.bitsets: {bits | <if (rest(rest(bits.tokens)))><bitsetBitfieldComparison(s, bits)><else><bitsetInlineComparison(s, bits)><endif>}; separator=" || ">
+>>
+
+// Java language spec 15.19 - shift operators mask operands rather than overflow to 0... need range test
+testShiftInRange(shiftAmount) ::= <<
+((<shiftAmount> & ~ 0x3fULL) == 0)
+>>
+
+bitsetBitfieldComparison(s, bits) ::= <<
+<testShiftInRange({<offsetShift(s.varName, bits.shift)>})> &&
+  ((1ULL \<\< <offsetShift(s.varName, bits.shift)>) & <bits.calculated>) != 0
+>>
+
+isZero ::= [
+  "0": true,
+  default: false
+]
+
+offsetShift(shiftAmount, offset, prefix = false) ::= <%
+<if (!isZero.(offset))>(<if (prefix)><parser.name>::TOKEN_<endif><shiftAmount> - <offset>)<else><if (prefix)><parser.name>::TOKEN_<endif><shiftAmount><endif>
+%>
+
+bitsetInlineComparison(s, bits) ::= <%
+<bits.tokens: {t | <s.varName> == <parser.name>::TOKEN_<t.name>}; separator = "\n\n|| ">
+%>
+
+cases(tokens) ::= <<
+<tokens: {t | case <parser.name>::TOKEN_<t.name>:}; separator="\n">
+>>
+
+InvokeRuleHeader(r, argExprsChunks) ::= "InvokeRuleHeader"
+InvokeRule(r, argExprsChunks) ::= <<
+{
+  setState(<r.stateNumber>);
+  invoked_stmt = "<r.name>";
+  auto res = <if(r.labels)><r.labels: {l | <labelref(l)> = }><endif><r.escapedName>(<if(r.ast.options.p)><r.ast.options.p><if(argExprsChunks)>,<endif><endif><argExprsChunks>);
+  if (parent && res) {
+    Y_ASSERT(dynamic_cast\<@ANTLR_PACKAGE_NAME@::TRule_<r.name>* >(res));
+    Y_ABORT_UNLESS(parent, "Parent is null");
+    parent->unsafe_arena_set_allocated_rule_<r.name><elemId>(static_cast\<@ANTLR_PACKAGE_NAME@::TRule_<r.name>* >(res));
+  \} else {
+    parent = nullptr;
+  }
+\}
+>>
+
+MatchTokenHeader(m) ::= "<! Required but unused. !>"
+MatchToken(m) ::= <<
+{
+  setState(<m.stateNumber>);
+  auto token = <if (m.labels)><m.labels: {l | <labelref(l)> = }><endif>match(<parser.name>::TOKEN_<m.escapedName>);
+  if (parent && token && token->getType() > 0) {
+    Y_ABORT_UNLESS(parent, "Parent is null");
+    parent->MutableToken<elemId>()->SetId(token->getType());
+    parent->MutableToken<elemId>()->SetLine(token->getLine());
+    parent->MutableToken<elemId>()->SetColumn(token->getCharPositionInLine());
+    parent->MutableToken<elemId>()->SetElement(<elemId>);
+    parent->MutableToken<elemId>()->SetValue(token->getText().c_str());
+  \} else {
+    parent = nullptr;
+  }
+}
+>>
+
+MatchSetHeader(m, expr, capture) ::= "<! Required but unused. !>"
+MatchSet(m, expr, capture) ::= "<CommonSetStuff(m, expr, capture, false)>"
+
+MatchNotSetHeader(m, expr, capture) ::= "<! Required but unused. !>"
+MatchNotSet(m, expr, capture) ::= "<CommonSetStuff(m, expr, capture, true)>"
+
+CommonSetStuff(m, expr, capture, invert) ::= <<
+setState(<m.stateNumber>);
+<if (m.labels)><m.labels: {l | <labelref(l)> = }>_input->LT(1);<endif>
+<capture>
+if (<if (invert)><m.varName> == 0 || <m.varName> == Token::EOF || <else>!<endif>(<expr>)) {
+  <if (m.labels)><m.labels: {l | <labelref(l)> = }><endif>_errHandler->recoverInline(this);
+}
+else {
+  auto token = _input->LT(1);
+  if (token && token->getType() > 0) {
+    Y_ABORT_UNLESS(parent, "Parent is null");
+    parent->MutableToken<elemId>()->SetId(token->getType());
+    parent->MutableToken<elemId>()->SetLine(token->getLine());
+    parent->MutableToken<elemId>()->SetColumn(token->getCharPositionInLine());
+    parent->MutableToken<elemId>()->SetElement(<elemId>);
+    parent->MutableToken<elemId>()->SetValue(token->getText().c_str());
+  }
+  _errHandler->reportMatch(this);
+  consume();
+}
+>>
+
+WildcardHeader(w) ::= "<! Required but unused. !>"
+Wildcard(w) ::= <<
+setState(<w.stateNumber>);
+<if (w.labels)><w.labels: {l | <labelref(l)> = }><endif>matchWildcard();
+>>
+
+// ACTION STUFF
+
+ActionHeader(a, foo, chunks) ::= "<chunks>"
+Action(a, foo, chunks) ::= "<chunks>"
+
+ArgAction(a, chunks) ::= "ArgAction(a, chunks) <chunks>"
+
+SemPredHeader(p, chunks, failChunks) ::= "<! Required but unused. !>"
+SemPred(p, chunks, failChunks) ::= <<
+setState(<p.stateNumber>);
+
+if (!(<chunks>)) throw FailedPredicateException(this, <p.predicate><if (failChunks)>, <failChunks><elseif (p.msg)>, <p.msg><endif>);
+>>
+
+ExceptionClauseHeader(e, catchArg, catchAction) ::= "<! Required but unused. !>"
+ExceptionClause(e, catchArg, catchAction) ::= <<
+catch (<catchArg>) {
+  <catchAction>
+}
+>>
+
+// Lexer actions are not associated with model objects.
+
+LexerSkipCommand()  ::= "skip();"
+LexerMoreCommand()  ::= "more();"
+LexerPopModeCommand() ::= "popMode();"
+
+LexerTypeCommand(arg, grammar)      ::= "type = <grammar.name>::<arg>;"
+LexerChannelCommand(arg, grammar)   ::= "channel = <arg>;"
+LexerModeCommand(arg, grammar)      ::= "mode = <grammar.name>Mode::<arg>;"
+LexerPushModeCommand(arg, grammar)  ::= "pushMode(<grammar.name>Mode::<arg>);"
+
+ActionTextHeader(t) ::= "<t.text>"
+ActionText(t) ::= "<t.text>"
+
+ActionTemplateHeader(t) ::= "<! Required but unused. !>"
+ActionTemplate(t) ::= "<t.st>"
+
+ArgRefHeader(t) ::= "<! Required but unused. !>"
+ArgRef(a) ::= "_localctx-><a.escapedName>"
+
+LocalRefHeader(t) ::= "<! Required but unused. !>"
+LocalRef(a) ::= "_localctx-><a.escapedName>"
+
+RetValueRefHeader(t) ::= "<! Required but unused. !>"
+RetValueRef(a) ::= "_localctx-><a.escapedName>"
+
+QRetValueRefHeader(t) ::= "<! Required but unused. !>"
+QRetValueRef(a) ::= "<ctx(a)>-><a.dict>-><a.escapedName>"
+/** How to translate $tokenLabel */
+
+TokenRefHeader(t) ::= "<! Required but unused. !>"
+TokenRef(t) ::= "<ctx(t)>-><t.escapedName>"
+
+LabelRefHeader(t) ::= "<! Required but unused. !>"
+LabelRef(t) ::= "<ctx(t)>-><t.escapedName>"
+
+ListLabelRefHeader(t) ::= "<! Required but unused. !>"
+ListLabelRef(t) ::= "<ctx(t)>-><ListLabelName(t.escapedName)>"
+
+SetAttrHeader(t) ::= "<! Required but unused. !>"
+SetAttr(s,rhsChunks) ::= "<ctx(s)>-><s.escapedName> = <rhsChunks>;"
+
+InputSymbolType() ::= "<file.InputSymbolType; null = {Token}> *"
+
+TokenPropertyRef_textHeader(t) ::= "<! Required but unused. !>"
+TokenPropertyRef_text(t) ::= <<(<ctx(t)>-><t.label> != nullptr ? <ctx(t)>-><t.label>->getText() : "")>>
+
+TokenPropertyRef_typeHeader(t) ::= "<! Required but unused. !>"
+TokenPropertyRef_type(t) ::= "(<ctx(t)>-><t.label> != nullptr ? <ctx(t)>-><t.label>->getType() : 0)"
+
+TokenPropertyRef_lineHeader(t) ::= "<! Required but unused. !>"
+TokenPropertyRef_line(t) ::= "(<ctx(t)>-><t.label> != nullptr ? <ctx(t)>-><t.label>->getLine() : 0)"
+
+TokenPropertyRef_posHeader(t) ::= "<! Required but unused. !>"
+TokenPropertyRef_pos(t) ::= "(<ctx(t)>-><t.label> != nullptr ? <ctx(t)>-><t.label>->getCharPositionInLine() : 0)"
+
+TokenPropertyRef_channelHeader(t) ::= "<! Required but unused. !>"
+TokenPropertyRef_channel(t) ::= "(<ctx(t)>-><t.label> != nullptr ? <ctx(t)>-><t.label>->getChannel() : 0)"
+
+TokenPropertyRef_indexHeader(t) ::= "<! Required but unused. !>"
+TokenPropertyRef_index(t) ::= "(<ctx(t)>-><t.label> != nullptr ? <ctx(t)>-><t.label>->getTokenIndex() : 0)"
+
+TokenPropertyRef_intHeader(t) ::= "<! Required but unused. !>"
+TokenPropertyRef_int(t) ::= "(<ctx(t)>-><t.label> != nullptr ? std::stoi(<ctx(t)>-><t.label>->getText()) : 0)"
+
+RulePropertyRef_startHeader(r)  ::= "<! Required but unused. !>"
+RulePropertyRef_start(r) ::= "(<ctx(r)>-><r.label> != nullptr ? (<ctx(r)>-><r.label>->start) : nullptr)"
+
+RulePropertyRef_stopHeader(r)  ::= "<! Required but unused. !>"
+RulePropertyRef_stop(r)  ::= "(<ctx(r)>-><r.label> != nullptr ? (<ctx(r)>-><r.label>->stop) : nullptr)"
+
+RulePropertyRef_textHeader(r)  ::= "<! Required but unused. !>"
+RulePropertyRef_text(r)  ::= "(<ctx(r)>-><r.label> != nullptr ? _input->getText(<ctx(r)>-><r.label>->start, <ctx(r)>-><r.label>->stop) : nullptr)"
+
+RulePropertyRef_ctxHeader(r)   ::= "<! Required but unused. !>"
+RulePropertyRef_ctx(r)   ::= "<ctx(r)>-><r.label>"
+
+ThisRulePropertyRef_start(r) ::= "ThisRulePropertyRef_start(r) _localctx->start"
+ThisRulePropertyRef_stop(r)  ::= "ThisRulePropertyRef_stop(r) _localctx->stop"
+
+ThisRulePropertyRef_textHeader(r)  ::= "<! Required but unused. !>"
+ThisRulePropertyRef_text(r)  ::= "_input->getText(_localctx->start, _input->LT(-1))"
+
+ThisRulePropertyRef_ctxHeader(r)   ::= "<! Required but unused. !>"
+ThisRulePropertyRef_ctx(r)   ::= "_localctx"
+
+ThisRulePropertyRef_parserHeader(r)	 ::= "<! Required but unused. !>"
+ThisRulePropertyRef_parser(r)	 ::= "this"
+
+NonLocalAttrRef(s) ::= "NonLocalAttrRef(s) ((<s.ruleName; format=\"cap\">Context)getInvokingContext(<s.ruleIndex>)).<s.escapedName>"
+SetNonLocalAttr(s, rhsChunks) ::=
+  "SetNonLocalAttr(s, rhsChunks) ((<s.ruleName; format=\"cap\">Context)getInvokingContext(<s.ruleIndex>)).<s.escapedName> = <rhsChunks>;"
+
+AddToLabelListHeader(a) ::= "<! Required but unused. !>"
+AddToLabelList(a) ::= <<
+<ctx(a.label)>-><a.listName>.push_back(<labelref(a.label)>);
+>>
+
+TokenLabelType() ::= "<file.TokenLabelType; null = {Token}> *"
+
+TokenDeclHeader(t) ::= "antlr4::<TokenLabelType()><t.escapedName> = nullptr"
+TokenDecl(t) ::= "<! Variable Declaration !>"
+
+TokenTypeDeclHeader(t) ::= "<! Local Variable !>"
+TokenTypeDecl(t) ::= "size_t <t.escapedName> = 0;"
+
+TokenListDeclHeader(t) ::= "std::vector\<antlr4::Token *> <t.escapedName>"
+TokenListDecl(t) ::= "<! Variable Declaration !>"
+
+RuleContextDeclHeader(r) ::= "<parser.name>::<r.ctxName> *<r.escapedName> = nullptr"
+RuleContextDecl(r) ::= "<! Variable Declaration !>"
+
+RuleContextListDeclHeader(rdecl) ::= "std::vector\<<rdecl.ctxName> *> <rdecl.escapedName>"
+RuleContextListDecl(rdecl) ::= "<! Variable Declaration !>"
+
+ContextTokenGetterDeclHeader(t) ::= "antlr4::tree::TerminalNode *TOKEN_<t.escapedName>();"
+ContextTokenGetterDecl(t) ::= <<
+tree::TerminalNode* <parser.name>::<t.ctx.name>::TOKEN_<t.escapedName>() {
+  return getToken(<parser.name>::TOKEN_<t.escapedName>, 0);
+}
+
+>>
+
+ContextTokenListGetterDeclHeader(t) ::= "std::vector\<antlr4::tree::TerminalNode *> TOKEN_<t.escapedName>();"
+ContextTokenListGetterDecl(t) ::= <<
+std::vector\<tree::TerminalNode *> <parser.name>::<t.ctx.name>::TOKEN_<t.escapedName>() {
+  return getTokens(<parser.name>::TOKEN_<t.escapedName>);
+}
+
+>>
+
+ContextTokenListIndexedGetterDeclHeader(t) ::= "antlr4::tree::TerminalNode* TOKEN_<t.escapedName>(size_t i);"
+ContextTokenListIndexedGetterDecl(t)  ::= <<
+tree::TerminalNode* <parser.name>::<t.ctx.name>::TOKEN_<t.escapedName>(size_t i) {
+  return getToken(<parser.name>::TOKEN_<t.escapedName>, i);
+}
+
+>>
+
+ContextRuleGetterDeclHeader(r) ::= "<r.ctxName> *<r.escapedName>();"
+ContextRuleGetterDecl(r) ::= <<
+<! Note: ctxName is the name of the context to return, while ctx is the owning context. !>
+<parser.name>::<r.ctxName>* <parser.name>::<r.ctx.name>::<r.escapedName>() {
+  return getRuleContext\<<parser.name>::<r.ctxName>\>(0);
+}
+
+>>
+
+ContextRuleListGetterDeclHeader(r) ::= "std::vector\<<r.ctxName> *> <r.escapedName>();"
+ContextRuleListGetterDecl(r) ::= <<
+std::vector\<<parser.name>::<r.ctxName> *> <parser.name>::<r.ctx.name>::<r.escapedName>() {
+  return getRuleContexts\<<parser.name>::<r.ctxName>\>();
+}
+
+>>
+
+ContextRuleListIndexedGetterDeclHeader(r) ::= "<r.ctxName>* <r.escapedName>(size_t i);"
+ContextRuleListIndexedGetterDecl(r) ::= <<
+<parser.name>::<r.ctxName>* <parser.name>::<r.ctx.name>::<r.escapedName>(size_t i) {
+  return getRuleContext\<<parser.name>::<r.ctxName>\>(i);
+}
+
+>>
+
+LexerRuleContext() ::= "antlr4::RuleContext"
+
+// The rule context name is the rule followed by a suffix; e.g. r becomes rContext.
+RuleContextNameSuffix() ::= "Context"
+
+ImplicitTokenLabel(tokenName) ::= <<
+<tokenName; format = "lower">Token
+>>
+
+ImplicitRuleLabel(ruleName) ::= "<ruleName>Context"
+ImplicitSetLabel(id) ::= "_tset<id>"
+ListLabelName(label) ::= "<label>"
+
+CaptureNextToken(d) ::= "CaptureNextToken(d) <d.varName> = _input->LT(1);"
+
+CaptureNextTokenTypeHeader(d) ::= "<! Required but unused. !>"
+CaptureNextTokenType(d) ::= "<d.varName> = _input->LA(1);"
+
+ListenerDispatchMethodHeader(method) ::= <<
+virtual void <if (method.isEnter)>enter<else>exit<endif>Rule(antlr4::tree::ParseTreeListener *listener) override;
+>>
+ListenerDispatchMethod(method) ::= <<
+void <parser.name>::<struct.escapedName>::<if (method.isEnter)>enter<else>exit<endif>Rule(tree::ParseTreeListener *listener) {
+  auto parserListener = dynamic_cast\<<parser.grammarName>Listener *>(listener);
+  if (parserListener != nullptr)
+    parserListener-><if(method.isEnter)>enter<else>exit<endif><struct.derivedFromName; format="cap">(this);
+}
+>>
+
+VisitorDispatchMethodHeader(method) ::= <<
+
+virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
+>>
+VisitorDispatchMethod(method) ::=  <<
+
+std::any <parser.name>::<struct.escapedName>::accept(tree::ParseTreeVisitor *visitor) {
+  if (auto parserVisitor = dynamic_cast\<<parser.grammarName>Visitor*>(visitor))
+    return parserVisitor->visit<struct.derivedFromName; format="cap">(this);
+  else
+    return visitor->visitChildren(this);
+}
+>>
+
+AttributeDeclHeader(d) ::= "<d.type> <d.escapedName><if(d.initValue)> = <d.initValue><endif>"
+AttributeDecl(d) ::= "<d.type> <d.escapedName>"
+
+/** If we don't know location of label def x, use this template */
+labelref(x) ::= "<if (!x.isLocal)>antlrcpp::downCast\<<x.ctx.name> *>(_localctx)-><endif><x.escapedName>"
+
+/** For any action chunk, what is correctly-typed context struct ptr? */
+ctx(actionChunk) ::= "antlrcpp::downCast\<<actionChunk.ctx.name> *>(_localctx)"
+
+// used for left-recursive rules
+recRuleAltPredicate(ruleName,opPrec) ::= "precpred(_ctx, <opPrec>)"
+recRuleSetReturnAction(src,name) ::= "recRuleSetReturnAction(src,name) $<name>=$<src>.<name>;"
+recRuleSetStopToken() ::= "_ctx->stop = _input->LT(-1);"
+
+recRuleAltStartAction(ruleName, ctxName, label, isListLabel) ::= <<
+_localctx = _tracker.createInstance\<<ctxName>Context>(parentContext, parentState);
+<if(label)>
+<if(isListLabel)>
+_localctx-><label>.push_back(previousContext);
+<else>
+_localctx-><label> = previousContext;
+<endif>
+<endif>
+pushNewRecursionContext(_localctx, startState, Rule<ruleName; format = "cap">);
+>>
+
+// Separate context variable to avoid frequent pointer type casts.
+recRuleLabeledAltStartAction(ruleName, currentAltLabel, label, isListLabel) ::= <<
+auto newContext = _tracker.createInstance\<<currentAltLabel; format = "cap">Context>(_tracker.createInstance\<<ruleName; format="cap">Context>(parentContext, parentState));
+_localctx = newContext;
+<if(label)>
+<if(isListLabel)>
+newContext-><label>.push_back(previousContext);
+<else>
+newContext-><label> = previousContext;
+<endif>
+<endif>
+pushNewRecursionContext(newContext, startState, Rule<ruleName; format = "cap">);
+>>
+
+recRuleReplaceContext(ctxName) ::= <<
+_localctx = _tracker.createInstance\<<ctxName>Context>(_localctx);
+_ctx = _localctx;
+previousContext = _localctx;
+>>
+
+recRuleSetPrevCtx() ::= <<
+if (!_parseListeners.empty())
+  triggerExitRuleEvent();
+previousContext = _localctx;
+>>
+
+/** Using a type to init value map, try to init a type; if not in table
+ *  must be an object, default value is "null".
+ */
+initValue(typeName) ::= <<
+<cppTypeInitMap.(typeName)>
+>>
diff --git a/ydb/library/yql/parser/proto_ast/org/antlr/v4/tool/templates/codegen/Cpp/Files.stg.in b/ydb/library/yql/parser/proto_ast/org/antlr/v4/tool/templates/codegen/Cpp/Files.stg.in
new file mode 100644
index 000000000000..6c147c7ac8cb
--- /dev/null
+++ b/ydb/library/yql/parser/proto_ast/org/antlr/v4/tool/templates/codegen/Cpp/Files.stg.in
@@ -0,0 +1,347 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2016, Mike Lischke
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *  3. The name of the author may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ *  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ *  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+codeFileExtension() ::= ".cpp"
+headerFileExtension() ::= ".h"
+
+fileHeader(grammarFileName, ANTLRVersion, header) ::= <<
+<header>
+
+// Generated from <grammarFileName> by ANTLR <ANTLRVersion>
+>>
+
+LexerFileHeader(file, lexer, namedActions) ::= <<
+<fileHeader(file.grammarFileName, file.ANTLRVersion, namedActions.header)>
+
+#pragma once
+
+<namedActions.preinclude>
+
+#include "antlr4-runtime.h"
+
+<namedActions.postinclude>
+
+<if(file.genPackage)>namespace <file.genPackage> {<endif>
+
+<lexer>
+
+<if (file.genPackage)>
+}  // namespace <file.genPackage>
+<endif>
+>>
+
+LexerFile(file, lexer, namedActions) ::= <<
+<fileHeader(file.grammarFileName, file.ANTLRVersion, namedActions.header)>
+
+<namedActions.preinclude>
+
+#include "<file.lexer.name>.h"
+
+<namedActions.postinclude>
+
+using namespace antlr4;
+
+<if (file.genPackage)>using namespace <file.genPackage>;<endif>
+
+<lexer>
+
+>>
+
+ParserFileHeader(file, parser, namedActions, contextSuperClass) ::= <<
+<fileHeader(file.grammarFileName, file.ANTLRVersion, namedActions.header)>
+
+#pragma once
+
+<namedActions.preinclude>
+
+#include "antlr4-runtime.h"
+#include \<ydb/library/yql/parser/proto_ast/proto_ast.h>
+
+<namedActions.postinclude>
+
+<if (file.genPackage)>namespace <file.genPackage> {<endif>
+
+<parser>
+
+<if (file.genPackage)>
+}  // namespace <file.genPackage>
+<endif>
+>>
+
+ParserFile(file, parser, namedActions, contextSuperClass) ::= <<
+<fileHeader(file.grammarFileName, file.ANTLRVersion, namedActions.header)>
+
+<namedActions.preinclude>
+
+<if (file.genListener)>#include "<file.grammarName>Listener.h"<endif>
+<if (file.genVisitor)>#include "<file.grammarName>Visitor.h"<endif>
+
+#include "<file.parser.name>.h"
+#include \<ydb/library/yql/parser/proto_ast/proto_ast.h>
+#include \<@PROTOBUF_HEADER_PATH@/SQLv1Parser@PROTOBUF_SUFFIX_PATH@>
+
+<namedActions.postinclude>
+
+using namespace antlrcpp;
+<if (file.genPackage)>using namespace <file.genPackage>;<endif>
+<parser>
+
+>>
+
+BaseListenerFileHeader(file, header, namedActions) ::= <<
+<fileHeader(file.grammarFileName, file.ANTLRVersion, header)>
+
+#pragma once
+
+<namedActions.baselistenerpreinclude>
+
+#include "antlr4-runtime.h"
+#include "<file.grammarName>Listener.h"
+
+<namedActions.baselistenerpostinclude>
+
+<if(file.genPackage)>
+namespace <file.genPackage> {
+<endif>
+
+/**
+ * This class provides an empty implementation of <file.grammarName>Listener,
+ * which can be extended to create a listener which only needs to handle a subset
+ * of the available methods.
+ */
+class <file.exportMacro> <file.grammarName>BaseListener : public <file.grammarName>Listener {
+public:
+<namedActions.baselistenerdeclarations>
+
+<file.listenerNames: {lname |
+  virtual void enter<lname; format="cap">(<file.parserName>::<lname; format = "cap">Context * /*ctx*/) override { \}
+  virtual void exit<lname; format="cap">(<file.parserName>::<lname; format = "cap">Context * /*ctx*/) override { \}
+}; separator="\n">
+
+  virtual void enterEveryRule(antlr4::ParserRuleContext * /*ctx*/) override { }
+  virtual void exitEveryRule(antlr4::ParserRuleContext * /*ctx*/) override { }
+  virtual void visitTerminal(antlr4::tree::TerminalNode * /*node*/) override { }
+  virtual void visitErrorNode(antlr4::tree::ErrorNode * /*node*/) override { }
+
+<if (namedActions.baselistenermembers)>
+private:
+<namedActions.baselistenermembers>
+<endif>
+};
+
+<if (file.genPackage)>
+}  // namespace <file.genPackage>
+<endif>
+>>
+
+BaseListenerFile(file, header, namedActions) ::= <<
+<fileHeader(file.grammarFileName, file.ANTLRVersion, header)>
+
+<namedActions.baselistenerpreinclude>
+
+#include "<file.grammarName>BaseListener.h"
+
+<namedActions.baselistenerpostinclude>
+
+<if(file.genPackage)>
+using namespace <file.genPackage>;
+<endif>
+
+<namedActions.baselistenerdefinitions>
+>>
+
+ListenerFileHeader(file, header, namedActions) ::= <<
+<fileHeader(file.grammarFileName, file.ANTLRVersion, header)>
+
+#pragma once
+
+<namedActions.listenerpreinclude>
+
+#include "antlr4-runtime.h"
+#include "<file.parserName>.h"
+
+<namedActions.listenerpostinclude>
+
+<if(file.genPackage)>
+namespace <file.genPackage> {
+<endif>
+
+/**
+ * This interface defines an abstract listener for a parse tree produced by <file.parserName>.
+ */
+class <file.exportMacro> <file.grammarName>Listener : public antlr4::tree::ParseTreeListener {
+public:
+<namedActions.listenerdeclarations>
+
+<file.listenerNames: {lname |
+  virtual void enter<lname; format = "cap">(<file.parserName>::<lname; format ="cap">Context *ctx) = 0;
+  virtual void exit<lname; format = "cap">(<file.parserName>::<lname; format="cap">Context *ctx) = 0;
+}; separator = "\n">
+
+<if (namedActions.listenermembers)>
+private:
+<namedActions.listenermembers>
+<endif>
+};
+
+<if(file.genPackage)>
+}  // namespace <file.genPackage>
+<endif>
+>>
+
+ListenerFile(file, header, namedActions) ::= <<
+<fileHeader(file.grammarFileName, file.ANTLRVersion, header)>
+
+<namedActions.listenerpreinclude>
+
+#include "<file.grammarName>Listener.h"
+
+<namedActions.listenerpostinclude>
+
+<if(file.genPackage)>
+using namespace <file.genPackage>;
+<endif>
+
+<namedActions.listenerdefinitions>
+>>
+
+BaseVisitorFileHeader(file, header, namedActions) ::= <<
+<fileHeader(file.grammarFileName, file.ANTLRVersion, header)>
+
+#pragma once
+
+<namedActions.basevisitorpreinclude>
+
+#include "antlr4-runtime.h"
+#include "<file.grammarName>Visitor.h"
+
+<namedActions.basevisitorpostinclude>
+
+<if(file.genPackage)>
+namespace <file.genPackage> {
+<endif>
+
+/**
+ * This class provides an empty implementation of <file.grammarName>Visitor, which can be
+ * extended to create a visitor which only needs to handle a subset of the available methods.
+ */
+class <file.exportMacro> <file.grammarName>BaseVisitor : public <file.grammarName>Visitor {
+public:
+<namedActions.basevisitordeclarations>
+
+<file.visitorNames: { lname |
+  virtual std::any visit<lname; format = "cap">(<file.parserName>::<lname; format = "cap">Context *ctx) override {
+    return visitChildren(ctx);
+  \}
+}; separator="\n">
+
+<if (namedActions.basevisitormembers)>
+private:
+<namedActions.basevisitormembers>
+<endif>
+};
+
+<if(file.genPackage)>
+}  // namespace <file.genPackage>
+<endif>
+>>
+
+BaseVisitorFile(file, header, namedActions) ::= <<
+<fileHeader(file.grammarFileName, file.ANTLRVersion, header)>
+
+<namedActions.basevisitorpreinclude>
+
+#include "<file.grammarName>BaseVisitor.h"
+
+<namedActions.basevisitorpostinclude>
+
+<if(file.genPackage)>
+using namespace <file.genPackage>;
+<endif>
+
+<namedActions.basevisitordefinitions>
+
+>>
+
+VisitorFileHeader(file, header, namedActions) ::= <<
+<fileHeader(file.grammarFileName, file.ANTLRVersion, header)>
+
+#pragma once
+
+<namedActions.visitorpreinclude>
+
+#include "antlr4-runtime.h"
+#include "<file.parserName>.h"
+
+<namedActions.visitorpostinclude>
+
+<if(file.genPackage)>namespace <file.genPackage> {<endif>
+
+/**
+ * This class defines an abstract visitor for a parse tree
+ * produced by <file.parserName>.
+ */
+class <file.exportMacro> <file.grammarName>Visitor : public antlr4::tree::AbstractParseTreeVisitor {
+public:
+  <namedActions.visitordeclarations>
+
+  /**
+   * Visit parse trees produced by <file.parserName>.
+   */
+  <file.visitorNames: {lname |
+  virtual std::any visit<lname; format = "cap">(<file.parserName>::<lname; format = "cap">Context *context) = 0;
+  }; separator="\n">
+
+<if (namedActions.visitormembers)>
+private:
+<namedActions.visitormembers>
+<endif>
+};
+
+<if(file.genPackage)>
+}  // namespace <file.genPackage>
+<endif>
+>>
+
+VisitorFile(file, header, namedActions) ::= <<
+<fileHeader(file.grammarFileName, file.ANTLRVersion, header)>
+
+<namedActions.visitorpreinclude>
+
+#include "<file.grammarName>Visitor.h"
+
+<namedActions.visitorpostinclude>
+
+<if(file.genPackage)>
+using namespace <file.genPackage>;
+<endif>
+
+<namedActions.visitordefinitions>
+
+>>
\ No newline at end of file
diff --git a/ydb/library/yql/parser/proto_ast/org/antlr/v4/tool/templates/codegen/Java/Java.stg.in b/ydb/library/yql/parser/proto_ast/org/antlr/v4/tool/templates/codegen/Java/Java.stg.in
new file mode 100644
index 000000000000..fd27448f76ba
--- /dev/null
+++ b/ydb/library/yql/parser/proto_ast/org/antlr/v4/tool/templates/codegen/Java/Java.stg.in
@@ -0,0 +1,459 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2012-2016 Terence Parr
+ *  Copyright (c) 2012-2016 Sam Harwell
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *  3. The name of the author may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ *  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ *  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+javaTypeInitMap ::= [
+	"int":"0",
+	"long":"0",
+	"float":"0.0f",
+	"double":"0.0",
+	"boolean":"false",
+	"byte":"0",
+	"short":"0",
+	"char":"0",
+	default:"null" // anything other than a primitive type is an object
+]
+
+// args must be <object-model-object>, <fields-resulting-in-STs>
+
+ParserFile(file, parser, namedActions, contextSuperClass) ::= <<
+//
+// Generated with: -d64 -lib ./ -language protobuf
+
+syntax = "proto3";
+option cc_enable_arenas = true;
+
+package @ANTLR_PACKAGE_NAME@;
+
+message TToken {
+    uint32 Id = 1;
+    uint32 Line = 2;
+    uint32 Column = 3;
+    uint32 Element = 4;
+    string Value = 5;
+}
+
+<parser>
+
+message TSQLv1ParserAST {
+    <first(parser.funcs):{r | TRule_<r.currentRule.name> Rule_<r.currentRule.name> = 1;}; separator="">
+}
+>>
+
+ListenerFile(file, header, namedActions) ::= <<
+>>
+
+BaseListenerFile(file, header, namedActions) ::= <<
+>>
+
+VisitorFile(file, header, namedActions) ::= <<
+>>
+
+fileHeader(grammarFileName, ANTLRVersion) ::= <<
+// Generated from <grammarFileName; format="java-escape"> by ANTLR <ANTLRVersion>
+>>
+
+Parser(parser, funcs, atn, sempredFuncs, superClass) ::= <<
+<funcs; separator="\n\n">
+>>
+
+Parser_(parser, funcs, atn, sempredFuncs, ctor, superClass) ::= <<
+>>
+
+vocabulary(literalNames, symbolicNames) ::= <<
+>>
+
+dumpActions(recog, argFuncs, actionFuncs, sempredFuncs) ::= <<
+>>
+
+parser_ctor(p) ::= <<
+>>
+
+/* This generates a private method since the actionIndex is generated, making an
+ * overriding implementation impossible to maintain.
+ */
+RuleActionFunction(r, actions) ::= <<
+>>
+
+/* This generates a private method since the predIndex is generated, making an
+ * overriding implementation impossible to maintain.
+ */
+RuleSempredFunction(r, actions) ::= <<
+>>
+
+RuleFunction(currentRule,args,code,locals,ruleCtx,altLabelCtxs,namedActions,finallyAction,postamble,exceptions) ::= <<
+// rule $ANTLR start "<currentRule.name>"
+message TRule_<currentRule.name> {
+    <if((!rest(code))&&first(code).alts&&rest(first(code).alts))>
+    // some multiple alt block
+    <first(code).alts:{a | <altDecl(a,i)>}; separator="\n">
+    oneof Alt {
+        <first(code).alts:{a | TAlt<i> Alt_<currentRule.name><i> = <i>; }; separator="\n">
+    }
+    <else>
+    <code:{e | <element(e, i)>}; separator="\n">
+    <defineDescr(code)>
+    <endif>
+}
+// $ANTLR end "<currentRule.name>"
+>>
+
+LeftRecursiveRuleFunction(currentRule,args,code,locals,ruleCtx,altLabelCtxs,
+	namedActions,finallyAction,postamble) ::=
+<<
+// rule $ANTLR start "<currentRule.name>"
+message TRule_<currentRule.name> {
+    <if((!rest(code))&&first(code).alts&&rest(first(code).alts))>
+    // some multiple alt block
+    <first(code).alts:{a | <altDecl(a,i)>}; separator="\n">
+    oneof Alt {
+        <first(code).alts:{a | TAlt<i> Alt_<currentRule.name><i> = <i>; }; separator="\n">
+    }
+    <else>
+    // some common block
+    <code:{e | <element(e, i)>}; separator="\n">
+    <defineDescr(code)>
+    <endif>
+}
+// $ANTLR end "<currentRule.name>"
+>>
+
+CodeBlockForOuterMostAlt(currentOuterMostAltCodeBlock, locals, preamble, ops) ::= <<
+// CodeBlockForOuterMostAlt
+<CodeBlockForAlt(currentAltCodeBlock = currentOuterMostAltCodeBlock, ...)>
+>>
+
+CodeBlockForAlt(currentAltCodeBlock, locals, preamble, ops) ::= <<
+// CodeBlockForAlt
+<ops:{e | <element(e, i)>}; separator="\n">
+>>
+
+element(e, elemId) ::= <<
+<e>
+>>
+
+
+LL1AltBlock(choice, preamble, alts, error) ::= <<
+// LL1AltBlock
+<blockDecl()>
+TBlock<elemId> Block<elemId> = <elemId>;
+>>
+
+LL1OptionalBlock(choice, alts, error) ::= <<
+// LL1OptionalBlock
+<blockDecl()>
+TBlock<elemId> Block<elemId> = <elemId>;
+>>
+
+LL1OptionalBlockSingleAlt(choice, expr, alts, preamble, error, followExpr) ::= <<
+// LL1OptionalBlockSingleAlt
+<blockDecl()>
+TBlock<elemId> Block<elemId> = <elemId>;
+>>
+
+LL1StarBlockSingleAlt(choice, loopExpr, alts, preamble, iteration) ::= <<
+// LL1StarBlockSingleAlt
+<blockDecl()>
+repeated TBlock<elemId> Block<elemId> = <elemId>;
+>>
+
+LL1PlusBlockSingleAlt(choice, loopExpr, alts, preamble, iteration) ::= <<
+// LL1PlusBlockSingleAlt
+<blockDecl()>
+repeated TBlock<elemId> Block<elemId> = <elemId>;
+>>
+
+// LL(*) stuff
+
+AltBlock(choice, preamble, alts, error) ::= <<
+// AltBlock
+<blockDecl()>
+TBlock<elemId> Block<elemId> = <elemId>;
+>>
+
+OptionalBlock(choice, alts, error) ::= <<
+// OptionalBlock
+<blockDecl()>
+TBlock<elemId> Block<elemId> = <elemId>;
+>>
+
+StarBlock(choice, alts, sync, iteration) ::= <<
+// StarBlock
+<blockDecl()>
+repeated TBlock<elemId> Block<elemId> = <elemId>;
+>>
+
+PlusBlock(choice, alts, error) ::= <<
+// PlusBlock
+<blockDecl()>
+repeated TBlock<elemId> Block<elemId> = <elemId>;
+>>
+
+blockDecl() ::= <<
+message TBlock<elemId> {
+<if(rest(alts))>
+    <alts:{a | <altDecl(a,i)>}; separator="\n">
+    oneof Alt {
+        <alts:{a | TAlt<i> Alt<i> = <i>; }; separator="\n">
+    }
+<else>
+    <alts>
+    <defineDescr(alts)>
+<endif>
+}
+>>
+
+altDecl(alt,altNum) ::= <<
+message TAlt<altNum> {
+    <alt>
+    <defineDescr(alt)>
+}
+>>
+
+defineDescr(alt) ::= <<
+<if(rest(alt) || !alt.ops)>
+string Descr = <length([alt, file])>;
+<else>
+<if(first(alt.ops).ops)>
+<if(first(first(alt.ops).ops).ops)>
+// CodeBlockForOuterMostAlt -> CodeBlockForAlt -> CodeBlockForAlt
+string Descr = <length([first(first(alt.ops).ops).ops, file])>;
+<else>
+// CodeBlockForAlt -> CodeBlockForAlt
+string Descr = <length([first(alt.ops).ops, file])>;
+<endif>
+<else>
+string Descr = <length([alt.ops, file])>;
+<endif>
+<endif>
+>>
+
+Sync(s) ::= ""
+
+ThrowNoViableAlt(t) ::= ""
+
+TestSetInline(s) ::= <<
+>>
+
+// Java language spec 15.19 - shift operators mask operands rather than overflow to 0... need range test
+testShiftInRange(shiftAmount) ::= <<
+>>
+
+bitsetBitfieldComparison(s, bits) ::= <%
+%>
+
+isZero ::= [
+"0":true,
+default:false
+]
+
+offsetShift(shiftAmount, offset) ::= <%
+%>
+
+bitsetInlineComparison(s, bits) ::= <%
+%>
+
+cases(tokens) ::= <<
+>>
+
+InvokeRule(r, argExprsChunks) ::= <<
+TRule_<r.name> Rule_<r.name><elemId> = <elemId>;
+>>
+
+MatchToken(m) ::= <<
+TToken Token<elemId> = <elemId>;
+>>
+
+MatchSet(m, expr, capture) ::= <<
+TToken Token<elemId> = <elemId>;
+>>
+
+MatchNotSet(m, expr, capture) ::= ""
+
+CommonSetStuff(m, expr, capture, invert) ::= <<
+>>
+
+Wildcard(w) ::= <<
+>>
+
+// ACTION STUFF
+
+Action(a, foo, chunks) ::= ""
+
+ArgAction(a, chunks) ::= ""
+
+SemPred(p, chunks, failChunks) ::= <<
+>>
+
+ExceptionClause(e, catchArg, catchAction) ::= <<
+>>
+
+// lexer actions are not associated with model objects
+
+LexerSkipCommand()  ::= ""
+LexerMoreCommand()  ::= ""
+LexerPopModeCommand() ::= ""
+
+LexerTypeCommand(arg, grammar)      ::= ""
+LexerChannelCommand(arg, grammar)   ::= ""
+LexerModeCommand(arg, grammar)      ::= ""
+LexerPushModeCommand(arg, grammar)  ::= ""
+
+ActionText(t) ::= "// ActionText <t>"
+ActionTemplate(t) ::= "// ActionText <t>"
+ArgRef(a) ::= "// ArgRef <t>"
+LocalRef(a) ::= "// LocalRef <t>"
+RetValueRef(a) ::= ""
+QRetValueRef(a) ::= ""
+/** How to translate $tokenLabel */
+TokenRef(t) ::= "// TokenRef <t>"
+LabelRef(t) ::= "// LabelRef <t>"
+ListLabelRef(t) ::= ""
+SetAttr(s,rhsChunks) ::= ""
+
+TokenLabelType() ::= ""
+InputSymbolType() ::= ""
+
+TokenPropertyRef_text(t) ::= "// TokenPropertyRef_text <t>"
+TokenPropertyRef_type(t) ::= "// TokenPropertyRef_type <t>"
+TokenPropertyRef_line(t) ::= "// TokenPropertyRef_line <t>"
+TokenPropertyRef_pos(t) ::= ""
+TokenPropertyRef_channel(t) ::= ""
+TokenPropertyRef_index(t) ::= ""
+TokenPropertyRef_int(t) ::= ""
+
+RulePropertyRef_start(r) ::= ""
+RulePropertyRef_stop(r)	 ::= ""
+RulePropertyRef_text(r)	 ::= ""
+RulePropertyRef_ctx(r)	 ::= ""
+RulePropertyRef_parser(r)	 ::= ""
+
+ThisRulePropertyRef_start(r) ::= ""
+ThisRulePropertyRef_stop(r)	 ::= ""
+ThisRulePropertyRef_text(r)	 ::= ""
+ThisRulePropertyRef_ctx(r)	 ::= ""
+ThisRulePropertyRef_parser(r)	 ::= ""
+
+NonLocalAttrRef(s)		 ::= ""
+SetNonLocalAttr(s, rhsChunks)	  ::=
+    ""
+
+AddToLabelList(a) ::= ""
+
+TokenDecl(t) ::= "// TokenDecl <t>"
+TokenTypeDecl(t) ::= "// TokenTypeDecl <t>"
+TokenListDecl(t) ::= "// TokenListDecl <t>"
+RuleContextDecl(r) ::= "// RuleContextDecl<r>"
+RuleContextListDecl(rdecl) ::= ""
+
+ContextTokenGetterDecl(t)      ::=
+    ""
+ContextTokenListGetterDecl(t)  ::=
+    ""
+ContextTokenListIndexedGetterDecl(t)  ::= <<
+>>
+ContextRuleGetterDecl(r)       ::= <<
+>>
+ContextRuleListGetterDecl(r)   ::= <<
+>>
+ContextRuleListIndexedGetterDecl(r)   ::= <<
+>>
+
+LexerRuleContext() ::= "// LexerRuleContext"
+
+/** The rule context name is the rule followed by a suffix; e.g.,
+ *	r becomes rContext.
+ */
+RuleContextNameSuffix() ::= "Context"
+
+ImplicitTokenLabel(tokenName) ::= "// ImplicitTokenLabel <tokenName>"
+ImplicitRuleLabel(ruleName)	  ::= "// ImplicitRuleLabel <ruleName>"
+ImplicitSetLabel(id)		  ::= ""
+ListLabelName(label)		  ::= ""
+
+CaptureNextToken(d) ::= ""
+CaptureNextTokenType(d) ::= ""
+
+StructDecl(struct,ctorAttrs,attrs,getters,dispatchMethods,interfaces,extensionMembers)
+	::= <<
+>>
+
+AltLabelStructDecl(struct,attrs,getters,dispatchMethods) ::= <<
+>>
+
+ListenerDispatchMethod(method) ::= <<
+>>
+
+VisitorDispatchMethod(method) ::= <<
+>>
+
+AttributeDecl(d) ::= ""
+
+/** If we don't know location of label def x, use this template */
+labelref(x) ::= "<if(!x.isLocal)>((<x.ctx.name>)_localctx).<endif><x.escapedName>"
+
+/** For any action chunk, what is correctly-typed context struct ptr? */
+ctx(actionChunk) ::= "((<actionChunk.ctx.name>)_localctx)"
+
+// used for left-recursive rules
+recRuleAltPredicate(ruleName,opPrec)  ::= ""
+recRuleSetReturnAction(src,name)	  ::= ""
+recRuleSetStopToken()                 ::= ""
+
+recRuleAltStartAction(ruleName, ctxName, label, isListLabel) ::= <<
+>>
+
+recRuleLabeledAltStartAction(ruleName, currentAltLabel, label, isListLabel) ::= <<
+>>
+
+recRuleReplaceContext(ctxName) ::= <<
+>>
+
+recRuleSetPrevCtx() ::= <<
+>>
+
+
+LexerFile(lexerFile, lexer, namedActions) ::= <<
+>>
+
+Lexer(lexer, atn, actionFuncs, sempredFuncs, superClass) ::= <<
+>>
+
+SerializedJavaATN(model) ::= <<
+>>
+
+/** Using a type to init value map, try to init a type; if not in table
+ *	must be an object, default value is "null".
+ */
+initValue(typeName) ::= <<
+>>
+
+SerializedATN(model) ::= ""
+
+codeFileExtension() ::= ".proto"
\ No newline at end of file
diff --git a/ydb/library/yql/parser/proto_ast/org/antlr/v4/tool/templates/codegen/ya.make.incl b/ydb/library/yql/parser/proto_ast/org/antlr/v4/tool/templates/codegen/ya.make.incl
new file mode 100644
index 000000000000..483c2c256991
--- /dev/null
+++ b/ydb/library/yql/parser/proto_ast/org/antlr/v4/tool/templates/codegen/ya.make.incl
@@ -0,0 +1,13 @@
+SET(STG_INCLUDES
+   contrib/libs/antlr4_cpp_runtime/src/antlr4-runtime.h
+
+   util/generic/ptr.h
+   util/generic/string.h
+   util/generic/vector.h
+   util/stream/output.h
+   util/stream/str.h
+
+   google/protobuf/message.h
+
+   ydb/library/yql/parser/proto_ast/proto_ast.h
+)
diff --git a/ydb/library/yql/parser/proto_ast/proto_ast.cpp b/ydb/library/yql/parser/proto_ast/proto_ast.cpp
index 097ba08c8549..3b7b43553df7 100644
--- a/ydb/library/yql/parser/proto_ast/proto_ast.cpp
+++ b/ydb/library/yql/parser/proto_ast/proto_ast.cpp
@@ -43,3 +43,14 @@ void TErrorOutput::AddError(ui32 line, ui32 col, const TString& message) {
     }
     Err << "Line " << line << " column " << col << " error: " << message;
 }
+
+antlr4::YqlErrorListener::YqlErrorListener(NProtoAST::IErrorCollector* errors, bool* error)
+    : errors(errors), error(error)
+{
+}
+
+void antlr4::YqlErrorListener::syntaxError(Recognizer * /*recognizer*/, Token * /*offendingSymbol*/,
+  size_t line, size_t charPositionInLine, const std::string &msg, std::exception_ptr /*e*/)  {
+    *error = true;
+    errors->Error(line, charPositionInLine, msg.c_str());
+}
\ No newline at end of file
diff --git a/ydb/library/yql/parser/proto_ast/proto_ast.h b/ydb/library/yql/parser/proto_ast/proto_ast.h
index 6bc8db23a96d..ddc3fc1a58e9 100644
--- a/ydb/library/yql/parser/proto_ast/proto_ast.h
+++ b/ydb/library/yql/parser/proto_ast/proto_ast.h
@@ -2,14 +2,33 @@
 
 #include <ydb/library/yql/parser/lexer_common/lexer.h>
 
+
+#include <contrib/libs/antlr4_cpp_runtime/src/antlr4-runtime.h>
 #include <contrib/libs/antlr3_cpp_runtime/include/antlr3.hpp>
 
 #include <google/protobuf/message.h>
 #include <util/generic/ptr.h>
 #include <util/generic/vector.h>
 #include <util/charset/utf8.h>
+#include <type_traits>
+
+template<typename T>
+struct IsDerivedFromLexer
+{
+    static constexpr bool value = std::is_base_of<antlr4::Lexer, T>::value;
+};
+
+template<typename T>
+struct IsDerivedFromParser
+{
+    static constexpr bool value = std::is_base_of<antlr4::Parser, T>::value;
+};
+
 
 namespace NProtoAST {
+    static const char* INVALID_TOKEN_NAME = "nothing";
+    static const char* ABSENCE = " absence";
+
     template <typename InputType>
     void InvalidCharacter(IOutputStream& err, const InputType* input) {
         wchar32 rune = 0;
@@ -21,13 +40,25 @@ namespace NProtoAST {
         }
     }
 
+
     template <typename TokenType>
-    void InvalidToken(IOutputStream& err, const TokenType* token) {
+    inline void InvalidToken(IOutputStream& err, const TokenType* token) {
         if (token) {
             if (token->get_input()) {
                 err << " '" << token->getText() << "'";
             } else {
-                err << " absence";
+                err << ABSENCE;
+            }
+        }
+    }
+
+    template <>
+    inline void InvalidToken<antlr4::Token>(IOutputStream& err, const antlr4::Token* token) {
+        if (token) {
+            if (token->getInputStream()) {
+                err << " '" << token->getText() << "'";
+            } else {
+                err << ABSENCE;
             }
         }
     }
@@ -64,8 +95,29 @@ namespace NProtoAST {
         TString Name;
     };
 
+} // namespace NProtoAST
+
+namespace antlr4 {
+    class ANTLR4CPP_PUBLIC YqlErrorListener : public BaseErrorListener {
+        NProtoAST::IErrorCollector* errors;
+        bool* error;
+    public:
+        static ConsoleErrorListener INSTANCE;
+
+        YqlErrorListener(NProtoAST::IErrorCollector* errors, bool* error);
+
+        virtual void syntaxError(Recognizer *recognizer, Token * offendingSymbol, size_t line, size_t charPositionInLine,
+                                const std::string &msg, std::exception_ptr e) override;
+    };
+}
+
+namespace NProtoAST {
+
+    template <typename TParser, typename TLexer,  bool IsAntlr4 = IsDerivedFromLexer<TLexer>::value && IsDerivedFromParser<TParser>::value>
+    class TProtoASTBuilder;
+
     template <typename TParser, typename TLexer>
-    class TProtoASTBuilder {
+    class TProtoASTBuilder<TParser, TLexer, false> {
         typedef ANTLR_UINT8 TChar;
 
     public:
@@ -101,8 +153,55 @@ namespace NProtoAST {
         TParser Parser;
     };
 
+    template <typename TParser, typename TLexer>
+    class TProtoASTBuilder<TParser, TLexer, true> {
+
+    public:
+        TProtoASTBuilder(TStringBuf data, const TString& queryName = "query", google::protobuf::Arena* arena = nullptr)
+            : QueryName(queryName)
+            , InputStream(std::string(data))  // Why the hell antlr needs non-const ptr??
+            , Lexer(&InputStream)
+            , TokenStream(&Lexer)
+            , Parser(&TokenStream, arena)
+        {
+        }
+
+        google::protobuf::Message* BuildAST(IErrorCollector& errors) {
+            // TODO: find a better way to break on lexer errors
+            typename antlr4::YqlErrorListener listener(&errors, &Parser.error);
+            Parser.addErrorListener(&listener);
+            try {
+                auto result = Parser.Parse(&errors);
+                Parser.removeErrorListener(&listener);
+                Parser.error = false;
+                return result;
+            } catch (const TTooManyErrors&) {
+                Parser.removeErrorListener(&listener);
+                Parser.error = false;
+                return nullptr;
+            } catch (const yexception& e) {
+                errors.Error(0, 0, e.what());
+                Parser.removeErrorListener(&listener);
+                Parser.error = false;
+                return nullptr;
+            }
+        }
+
+    private:
+        TString QueryName;
+
+        antlr4::ANTLRInputStream InputStream;
+        TLexer Lexer;
+
+        antlr4::CommonTokenStream TokenStream;
+        TParser Parser;
+    };
+
+    template <typename TLexer, bool IsAntlr4 = IsDerivedFromLexer<TLexer>::value>
+    class TLexerTokensCollector;
+
     template <typename TLexer>
-    class TLexerTokensCollector {
+    class TLexerTokensCollector<TLexer, false> {
         typedef ANTLR_UINT8 TChar;
 
     public:
@@ -144,4 +243,51 @@ namespace NProtoAST {
         typename TLexer::InputStreamType InputStream;
         TLexer Lexer;
     };
+
+    template <typename TLexer>
+    class TLexerTokensCollector<TLexer, true> {
+
+    public:
+        TLexerTokensCollector(TStringBuf data, const TString& queryName = "query")
+            : QueryName(queryName)
+            , InputStream(std::string(data))
+            , Lexer(&InputStream)
+        {
+        }
+
+        void CollectTokens(IErrorCollector& errors, const NSQLTranslation::ILexer::TTokenCallback& onNextToken) {
+            try {
+                for (;;) {
+                    auto token = Lexer.nextToken();
+                    auto type = token->getType();
+                    const bool isEOF = type == TLexer::EOF;
+                    NSQLTranslation::TParsedToken last;
+                    last.Name = GetTokenName(type);
+                    last.Content = token->getText();
+                    last.Line = token->getLine();
+                    last.LinePos = token->getCharPositionInLine();
+                    onNextToken(std::move(last));
+                    if (isEOF) {
+                        break;
+                    }
+                }
+            } catch (const TTooManyErrors&) {
+            } catch (const yexception& e) {
+                errors.Error(0, 0, e.what());
+            }
+        }
+
+    private:
+        TString GetTokenName(size_t type) const {
+            auto res = Lexer.getVocabulary().getSymbolicName(type);
+            if (res != ""){
+                return TString(res);
+            }
+            return TString(INVALID_TOKEN_NAME);
+        }
+
+        TString QueryName;
+        antlr4::ANTLRInputStream InputStream;
+        TLexer Lexer;
+    };
 } // namespace NProtoAST
diff --git a/ydb/library/yql/parser/proto_ast/ya.make b/ydb/library/yql/parser/proto_ast/ya.make
index 8251c29c182f..76ee1e9c20a6 100644
--- a/ydb/library/yql/parser/proto_ast/ya.make
+++ b/ydb/library/yql/parser/proto_ast/ya.make
@@ -2,6 +2,7 @@ LIBRARY()
 
 PEERDIR(
     contrib/libs/antlr3_cpp_runtime
+    contrib/libs/antlr4_cpp_runtime
     contrib/libs/protobuf
 )
 
diff --git a/ydb/library/yql/sql/settings/translation_settings.cpp b/ydb/library/yql/sql/settings/translation_settings.cpp
index 6b86b7a0bd1c..6e113ba42fa4 100644
--- a/ydb/library/yql/sql/settings/translation_settings.cpp
+++ b/ydb/library/yql/sql/settings/translation_settings.cpp
@@ -53,6 +53,7 @@ namespace NSQLTranslation {
         , EnableGenericUdfs(true)
         , SyntaxVersion(1)
         , AnsiLexer(false)
+        , Antlr4Parser(false)
         , PgParser(false)
         , InferSyntaxVersion(false)
         , V0Behavior(EV0Behavior::Disable)
@@ -121,6 +122,8 @@ namespace NSQLTranslation {
                 settings.SyntaxVersion = 1;
             } else if (value == "ansi_lexer") {
                 settings.AnsiLexer = true;
+            } else if (value == "antlr4_parser") {
+                settings.Antlr4Parser = true;
             } else if (value == "syntax_pg") {
                 settings.PgParser = true;
             } else {
diff --git a/ydb/library/yql/sql/settings/translation_settings.h b/ydb/library/yql/sql/settings/translation_settings.h
index cc623c08b0d8..8470bf09ae02 100644
--- a/ydb/library/yql/sql/settings/translation_settings.h
+++ b/ydb/library/yql/sql/settings/translation_settings.h
@@ -101,6 +101,7 @@ namespace NSQLTranslation {
         bool EnableGenericUdfs;
         ui16 SyntaxVersion;
         bool AnsiLexer;
+        bool Antlr4Parser;
         bool PgParser;
         bool InferSyntaxVersion;
         EV0Behavior V0Behavior;
diff --git a/ydb/library/yql/sql/sql.cpp b/ydb/library/yql/sql/sql.cpp
index e4f29d6bb45d..bc643e8f1723 100644
--- a/ydb/library/yql/sql/sql.cpp
+++ b/ydb/library/yql/sql/sql.cpp
@@ -125,7 +125,7 @@ namespace NSQLTranslation {
 
                 return NSQLTranslationV0::MakeLexer();
             case 1:
-                return NSQLTranslationV1::MakeLexer(parsedSettings.AnsiLexer);
+                return NSQLTranslationV1::MakeLexer(parsedSettings.AnsiLexer, parsedSettings.Antlr4Parser);
             default:
                 issues.AddIssue(NYql::YqlIssue(NYql::TPosition(), NYql::TIssuesIds::DEFAULT_ERROR,
                     TStringBuilder() << "Unknown SQL syntax version: " << parsedSettings.SyntaxVersion));
diff --git a/ydb/library/yql/sql/v1/SQLv1Antlr4.g.in b/ydb/library/yql/sql/v1/SQLv1Antlr4.g.in
new file mode 100644
index 000000000000..849452cd9305
--- /dev/null
+++ b/ydb/library/yql/sql/v1/SQLv1Antlr4.g.in
@@ -0,0 +1,2091 @@
+grammar SQLv1Antlr4;
+
+options {
+    language = Cpp;
+}
+
+// Input is a list of statements.
+sql_query: sql_stmt_list | PRAGMA ANSI DIGITS ansi_sql_stmt_list;
+sql_stmt_list: SEMICOLON* sql_stmt (SEMICOLON+ sql_stmt)* SEMICOLON* EOF;
+ansi_sql_stmt_list: SEMICOLON* EOF;
+
+lambda_body: SEMICOLON* (lambda_stmt SEMICOLON+)* RETURN expr SEMICOLON*;
+lambda_stmt:
+    named_nodes_stmt
+  | import_stmt
+;
+
+sql_stmt: (EXPLAIN (TQ TU TE TR TY PLAN)?)? sql_stmt_core;
+
+sql_stmt_core:
+    pragma_stmt
+  | select_stmt
+  | named_nodes_stmt
+  | create_table_stmt
+  | drop_table_stmt
+  | use_stmt
+  | into_table_stmt
+  | commit_stmt
+  | update_stmt
+  | delete_stmt
+  | rollback_stmt
+  | declare_stmt
+  | import_stmt
+  | export_stmt
+  | alter_table_stmt
+  | alter_external_table_stmt
+  | do_stmt
+  | define_action_or_subquery_stmt
+  | if_stmt
+  | for_stmt
+  | values_stmt
+  | create_user_stmt
+  | alter_user_stmt
+  | create_group_stmt
+  | alter_group_stmt
+  | drop_role_stmt
+  | create_object_stmt
+  | alter_object_stmt
+  | drop_object_stmt
+  | create_external_data_source_stmt
+  | alter_external_data_source_stmt
+  | drop_external_data_source_stmt
+  | create_replication_stmt
+  | drop_replication_stmt
+  | create_topic_stmt
+  | alter_topic_stmt
+  | drop_topic_stmt
+  | grant_permissions_stmt
+  | revoke_permissions_stmt
+  | alter_table_store_stmt
+  | upsert_object_stmt
+  | create_view_stmt
+  | drop_view_stmt
+  | alter_replication_stmt
+  | create_resource_pool_stmt
+  | alter_resource_pool_stmt
+  | drop_resource_pool_stmt
+  | create_backup_collection_stmt
+  | alter_backup_collection_stmt
+  | drop_backup_collection_stmt
+  | analyze_stmt
+  | create_resource_pool_classifier_stmt
+  | alter_resource_pool_classifier_stmt
+  | drop_resource_pool_classifier_stmt
+;
+
+expr:
+    or_subexpr (OR or_subexpr)*
+  | type_name_composite;
+
+or_subexpr: and_subexpr (AND and_subexpr)*;
+
+and_subexpr: xor_subexpr (XOR xor_subexpr)*;
+
+xor_subexpr: eq_subexpr cond_expr?;
+
+distinct_from_op: IS NOT? DISTINCT FROM;
+
+cond_expr:
+    NOT? match_op eq_subexpr (ESCAPE eq_subexpr)?
+  | NOT? IN COMPACT? in_expr
+  | (ISNULL | NOTNULL | IS NULL | (IS)? NOT NULL)
+  | NOT? BETWEEN (SYMMETRIC | ASYMMETRIC)? eq_subexpr AND eq_subexpr
+  | ((EQUALS | EQUALS2 | NOT_EQUALS | NOT_EQUALS2 | distinct_from_op) eq_subexpr)+ /* order of the eq subexpressions is reversed! */
+;
+
+match_op: LIKE | ILIKE | GLOB | REGEXP | RLIKE | MATCH;
+
+eq_subexpr: neq_subexpr ((LESS | LESS_OR_EQ | GREATER | GREATER_OR_EQ) neq_subexpr)*;
+
+// workaround for recursive types, '??' and closing '>>'
+shift_right: GREATER GREATER;
+rot_right: GREATER GREATER PIPE;
+double_question: QUESTION QUESTION;
+
+neq_subexpr: bit_subexpr ((SHIFT_LEFT | shift_right | ROT_LEFT | rot_right | AMPERSAND | PIPE | CARET) bit_subexpr)*
+  // trailing QUESTIONs are used in optional simple types (String?) and optional lambda args: ($x, $y?) -> ($x)
+  (double_question neq_subexpr | QUESTION+)?;
+
+bit_subexpr: add_subexpr ((PLUS | MINUS) add_subexpr)*;
+
+add_subexpr: mul_subexpr ((ASTERISK | SLASH | PERCENT) mul_subexpr)*;
+
+mul_subexpr: con_subexpr (DOUBLE_PIPE con_subexpr)*;
+
+con_subexpr: unary_subexpr | unary_op unary_subexpr;
+
+unary_op: PLUS | MINUS | TILDA | NOT;
+
+unary_subexpr_suffix: ((key_expr | invoke_expr | DOT (bind_parameter | DIGITS | an_id_or_type)))* (COLLATE an_id)?;
+
+unary_casual_subexpr: (id_expr | atom_expr) unary_subexpr_suffix;
+
+in_unary_casual_subexpr: (id_expr_in | in_atom_expr) unary_subexpr_suffix;
+
+unary_subexpr:    unary_casual_subexpr | json_api_expr;
+
+in_unary_subexpr: in_unary_casual_subexpr | json_api_expr;
+
+list_literal: LBRACE_SQUARE expr_list? COMMA? RBRACE_SQUARE;
+
+expr_dict_list: expr (COLON expr)? (COMMA expr (COLON expr)?)*;
+
+dict_literal: LBRACE_CURLY expr_dict_list? COMMA? RBRACE_CURLY;
+
+expr_struct_list: expr COLON expr (COMMA expr COLON expr)*;
+
+struct_literal: STRUCT_OPEN expr_struct_list? COMMA? STRUCT_CLOSE;
+
+atom_expr:
+    literal_value
+  | bind_parameter
+  | lambda
+  | cast_expr
+  | exists_expr
+  | case_expr
+  | an_id_or_type NAMESPACE (id_or_type | STRING_VALUE)
+  | value_constructor
+  | bitcast_expr
+  | list_literal
+  | dict_literal
+  | struct_literal
+;
+
+in_atom_expr:
+    literal_value
+  | bind_parameter
+  | lambda
+  | cast_expr
+  | case_expr
+  | an_id_or_type NAMESPACE (id_or_type | STRING_VALUE)
+  | LPAREN select_stmt RPAREN
+// TODO: resolve ANTLR error: rule in_atom_expr has non-LL(*) decision due to recursive rule invocations reachable from alts 3,8
+//  | LPAREN values_stmt RPAREN
+  | value_constructor
+  | bitcast_expr
+  | list_literal
+  | dict_literal
+  | struct_literal
+;
+
+cast_expr: CAST LPAREN expr AS type_name_or_bind RPAREN;
+
+bitcast_expr: BITCAST LPAREN expr AS type_name_simple RPAREN;
+
+exists_expr: EXISTS LPAREN (select_stmt | values_stmt) RPAREN;
+
+case_expr: CASE expr? when_expr+ (ELSE expr)? END;
+
+lambda: smart_parenthesis (ARROW (LPAREN expr RPAREN | LBRACE_CURLY lambda_body RBRACE_CURLY) )?;
+
+in_expr: in_unary_subexpr;
+
+// ANSI SQL JSON support
+json_api_expr: json_value | json_exists | json_query;
+
+jsonpath_spec: STRING_VALUE;
+
+json_variable_name: id_expr | STRING_VALUE;
+
+json_variable: expr AS json_variable_name;
+
+json_variables: json_variable (COMMA json_variable)*;
+
+json_common_args: expr COMMA jsonpath_spec (PASSING json_variables)?;
+
+json_case_handler: ERROR | NULL | DEFAULT expr;
+
+json_value: JSON_VALUE LPAREN
+  json_common_args
+  (RETURNING type_name_simple)?
+  (json_case_handler ON (EMPTY | ERROR))*
+RPAREN;
+
+json_exists_handler: (TRUE | FALSE | UNKNOWN | ERROR) ON ERROR;
+
+json_exists: JSON_EXISTS LPAREN
+  json_common_args
+  json_exists_handler?
+RPAREN;
+
+json_query_wrapper: WITHOUT ARRAY? | WITH (CONDITIONAL | UNCONDITIONAL)? ARRAY?;
+json_query_handler: ERROR | NULL | EMPTY ARRAY | EMPTY OBJECT;
+
+json_query: JSON_QUERY LPAREN
+  json_common_args
+  (json_query_wrapper WRAPPER)?
+  (json_query_handler ON EMPTY)?
+  (json_query_handler ON ERROR)?
+RPAREN;
+
+// struct, tuple or named list
+smart_parenthesis: LPAREN named_expr_list? COMMA? RPAREN;
+
+expr_list: expr (COMMA expr)*;
+
+pure_column_list: LPAREN an_id (COMMA an_id)* RPAREN;
+
+pure_column_or_named: bind_parameter | an_id;
+pure_column_or_named_list: LPAREN pure_column_or_named (COMMA pure_column_or_named)* RPAREN;
+
+column_name: opt_id_prefix an_id;
+without_column_name: an_id DOT an_id | an_id_without;
+
+column_list: column_name (COMMA column_name)* COMMA?;
+without_column_list: without_column_name (COMMA without_column_name)* COMMA?;
+
+named_expr: expr (AS an_id_or_type)?;
+
+named_expr_list: named_expr (COMMA named_expr)*;
+
+invoke_expr: LPAREN (opt_set_quantifier named_expr_list COMMA? | ASTERISK)? RPAREN invoke_expr_tail;
+
+// null_treatment can only happen after window functions LAG/LEAD/NTH/FIRST_VALUE/LAST_VALUE
+// filter_clause can only happen after aggregation functions
+invoke_expr_tail:
+    (null_treatment | filter_clause)? (OVER window_name_or_specification)?
+;
+
+using_call_expr: (an_id_or_type NAMESPACE an_id_or_type | an_id_expr | bind_parameter | EXTERNAL FUNCTION) invoke_expr;
+
+key_expr: LBRACE_SQUARE expr RBRACE_SQUARE;
+
+when_expr: WHEN expr THEN expr;
+
+literal_value:
+    integer
+  | real
+  | STRING_VALUE
+  | BLOB // it's unused right now
+  | NULL
+  | CURRENT_TIME // it's unused right now
+  | CURRENT_DATE // it's unused right now
+  | CURRENT_TIMESTAMP // it's unused right now
+  | bool_value
+  | EMPTY_ACTION
+;
+
+bind_parameter: DOLLAR (an_id_or_type | TRUE | FALSE);
+opt_bind_parameter: bind_parameter QUESTION?;
+
+bind_parameter_list: bind_parameter (COMMA bind_parameter)*;
+named_bind_parameter: bind_parameter (AS bind_parameter)?;
+named_bind_parameter_list: named_bind_parameter (COMMA named_bind_parameter)*;
+
+signed_number: (PLUS | MINUS)? (integer | real);
+
+type_name_simple: an_id_pure;
+
+integer_or_bind: integer | bind_parameter;
+type_name_tag: id | STRING_VALUE | bind_parameter;
+
+struct_arg: type_name_tag COLON type_name_or_bind;
+struct_arg_positional:
+    type_name_tag type_name_or_bind (NOT? NULL)?
+  | type_name_or_bind AS type_name_tag; //deprecated
+variant_arg: (type_name_tag COLON)? type_name_or_bind;
+callable_arg: variant_arg (LBRACE_CURLY AUTOMAP RBRACE_CURLY)?;
+callable_arg_list: callable_arg (COMMA callable_arg)*;
+
+type_name_decimal: DECIMAL LPAREN integer_or_bind COMMA integer_or_bind RPAREN;
+type_name_optional: OPTIONAL LESS type_name_or_bind GREATER;
+type_name_tuple: TUPLE (LESS (type_name_or_bind (COMMA type_name_or_bind)* COMMA?)? GREATER | NOT_EQUALS2);
+type_name_struct: STRUCT (LESS (struct_arg (COMMA struct_arg)* COMMA?)? GREATER | NOT_EQUALS2);
+type_name_variant: VARIANT LESS variant_arg (COMMA variant_arg)* COMMA? GREATER;
+type_name_list: LIST LESS type_name_or_bind GREATER;
+type_name_stream: STREAM LESS type_name_or_bind GREATER;
+type_name_flow: FLOW LESS type_name_or_bind GREATER;
+type_name_dict: DICT LESS type_name_or_bind COMMA type_name_or_bind GREATER;
+type_name_set: SET LESS type_name_or_bind GREATER;
+type_name_enum: ENUM LESS type_name_tag (COMMA type_name_tag)* COMMA? GREATER;
+type_name_resource: RESOURCE LESS type_name_tag GREATER;
+type_name_tagged: TAGGED LESS type_name_or_bind COMMA type_name_tag GREATER;
+type_name_callable: CALLABLE LESS LPAREN callable_arg_list? COMMA? (LBRACE_SQUARE callable_arg_list RBRACE_SQUARE)? RPAREN ARROW type_name_or_bind GREATER;
+
+type_name_composite:
+  ( type_name_optional
+  | type_name_tuple
+  | type_name_struct
+  | type_name_variant
+  | type_name_list
+  | type_name_stream
+  | type_name_flow
+  | type_name_dict
+  | type_name_set
+  | type_name_enum
+  | type_name_resource
+  | type_name_tagged
+  | type_name_callable
+  ) QUESTION*;
+
+type_name:
+    type_name_composite
+  | (type_name_decimal | type_name_simple) QUESTION*;
+
+type_name_or_bind: type_name | bind_parameter;
+
+value_constructor_literal: STRING_VALUE;
+value_constructor:
+    VARIANT LPAREN expr COMMA expr COMMA expr RPAREN
+  | ENUM LPAREN expr COMMA expr RPAREN
+  | CALLABLE LPAREN expr COMMA expr RPAREN
+;
+
+declare_stmt: DECLARE bind_parameter AS type_name (EQUALS literal_value)?;
+
+module_path: DOT? an_id (DOT an_id)*;
+import_stmt: IMPORT module_path SYMBOLS named_bind_parameter_list;
+export_stmt: EXPORT bind_parameter_list;
+
+call_action: (bind_parameter | EMPTY_ACTION) LPAREN expr_list? RPAREN;
+inline_action: BEGIN define_action_or_subquery_body END DO;
+do_stmt: DO (call_action | inline_action);
+pragma_stmt: PRAGMA opt_id_prefix_or_type an_id (EQUALS pragma_value | LPAREN pragma_value (COMMA pragma_value)* RPAREN)?;
+
+pragma_value:
+    signed_number
+  | id
+  | STRING_VALUE
+  | bool_value
+  | bind_parameter
+;
+
+/// TODO: NULLS FIRST\LAST?
+sort_specification: expr (ASC | DESC)?;
+
+sort_specification_list: sort_specification (COMMA sort_specification)*;
+
+select_stmt: select_kind_parenthesis (select_op select_kind_parenthesis)*;
+
+select_unparenthesized_stmt: select_kind_partial (select_op select_kind_parenthesis)*;
+
+select_kind_parenthesis: select_kind_partial | LPAREN select_kind_partial RPAREN;
+
+select_op: UNION (ALL)? | INTERSECT | EXCEPT;
+
+select_kind_partial: select_kind
+  (LIMIT expr ((OFFSET | COMMA) expr)?)?
+  ;
+
+select_kind: (DISCARD)? (process_core | reduce_core | select_core) (INTO RESULT pure_column_or_named)?;
+
+process_core:
+  PROCESS STREAM? named_single_source (COMMA named_single_source)* (USING using_call_expr (AS an_id)?
+  (WITH external_call_settings)?
+  (WHERE expr)? (HAVING expr)? (ASSUME order_by_clause)?)?
+;
+
+external_call_param: an_id EQUALS expr;
+external_call_settings: external_call_param (COMMA external_call_param)*;
+
+reduce_core:
+  REDUCE named_single_source (COMMA named_single_source)* (PRESORT sort_specification_list)?
+  ON column_list USING ALL? using_call_expr (AS an_id)?
+  (WHERE expr)? (HAVING expr)? (ASSUME order_by_clause)?
+;
+
+opt_set_quantifier: (ALL | DISTINCT)?;
+
+select_core:
+  (FROM join_source)? SELECT STREAM? opt_set_quantifier result_column (COMMA result_column)* COMMA? (WITHOUT without_column_list)? (FROM join_source)? (WHERE expr)?
+  group_by_clause? (HAVING expr)? window_clause? ext_order_by_clause?
+;
+
+// ISO/IEC 9075-2:2016(E) 7.7 <row pattern recognition clause>
+row_pattern_recognition_clause: MATCH_RECOGNIZE LPAREN
+    window_partition_clause?
+    order_by_clause?
+    row_pattern_measures?
+    row_pattern_rows_per_match?
+    row_pattern_common_syntax
+  RPAREN
+;
+
+row_pattern_rows_per_match:
+      ONE ROW PER MATCH
+    | ALL ROWS PER MATCH row_pattern_empty_match_handling?
+;
+
+row_pattern_empty_match_handling: SHOW EMPTY MATCHES | OMIT EMPTY MATCHES | WITH UNMATCHED ROWS;
+
+// ISO/IEC 9075-2:2016(E) 7.8 <row pattern measures>
+row_pattern_measures: MEASURES row_pattern_measure_list;
+
+row_pattern_measure_list: row_pattern_measure_definition (COMMA row_pattern_measure_definition)*;
+
+row_pattern_measure_definition: expr AS an_id;
+
+// ISO/IEC 9075-2:2016(E) 7.9 <row pattern common syntax>
+row_pattern_common_syntax:
+    (AFTER MATCH row_pattern_skip_to)?
+    row_pattern_initial_or_seek?
+    PATTERN LPAREN row_pattern RPAREN
+    row_pattern_subset_clause?
+    DEFINE row_pattern_definition_list
+;
+
+row_pattern_skip_to:
+      TSKIP TO NEXT ROW
+    | TSKIP PAST LAST ROW
+    | TSKIP TO FIRST row_pattern_skip_to_variable_name
+    | TSKIP TO LAST row_pattern_skip_to_variable_name
+    | TSKIP TO row_pattern_skip_to_variable_name
+;
+
+row_pattern_skip_to_variable_name: row_pattern_variable_name;
+
+row_pattern_initial_or_seek: INITIAL | SEEK;
+
+row_pattern: row_pattern_term (PIPE row_pattern_term)*;
+
+row_pattern_term: row_pattern_factor+;
+
+row_pattern_factor: row_pattern_primary row_pattern_quantifier?;
+
+row_pattern_quantifier:
+      ASTERISK QUESTION?
+    | PLUS QUESTION?
+    | QUESTION QUESTION?
+    | LBRACE_CURLY integer? COMMA integer? RBRACE_CURLY QUESTION?
+    | LBRACE_CURLY integer RBRACE_CURLY
+;
+
+row_pattern_primary:
+      row_pattern_primary_variable_name
+    | DOLLAR
+    | CARET
+    | LPAREN row_pattern? RPAREN
+    | LBRACE_CURLY MINUS row_pattern MINUS RBRACE_CURLY //TODO This rule accepts spaces between brace and minus sign, i.e: {   -  S2 - } that is not supposed to. Handle this case in https://st.yandex-team.ru/YQL-16227
+    | row_pattern_permute
+;
+
+row_pattern_primary_variable_name: row_pattern_variable_name;
+
+row_pattern_permute: PERMUTE LPAREN
+    row_pattern (COMMA row_pattern)*
+    RPAREN
+;
+
+row_pattern_subset_clause: SUBSET row_pattern_subset_list;
+
+row_pattern_subset_list: row_pattern_subset_item (COMMA row_pattern_subset_item)*;
+
+row_pattern_subset_item: row_pattern_subset_item_variable_name EQUALS LPAREN
+    row_pattern_subset_rhs RPAREN
+;
+
+row_pattern_subset_item_variable_name: row_pattern_variable_name;
+
+row_pattern_subset_rhs: row_pattern_subset_rhs_variable_name (COMMA row_pattern_subset_rhs_variable_name)*;
+
+row_pattern_subset_rhs_variable_name: row_pattern_variable_name;
+
+row_pattern_definition_list: row_pattern_definition (COMMA row_pattern_definition)*;
+
+row_pattern_definition: row_pattern_definition_variable_name AS row_pattern_definition_search_condition;
+
+row_pattern_definition_variable_name: row_pattern_variable_name;
+
+row_pattern_definition_search_condition: search_condition;
+
+search_condition: expr;
+
+//TODO allow use tokens as vars https://st.yandex-team.ru/YQL-16223
+row_pattern_variable_name: identifier;
+
+order_by_clause: ORDER BY sort_specification_list;
+
+ext_order_by_clause: ASSUME? order_by_clause;
+
+group_by_clause: GROUP COMPACT? BY opt_set_quantifier grouping_element_list (WITH an_id)?;
+
+grouping_element_list: grouping_element (COMMA grouping_element)*;
+
+grouping_element:
+    ordinary_grouping_set
+  | rollup_list
+  | cube_list
+  | grouping_sets_specification
+//empty_grouping_set inside smart_parenthesis
+  | hopping_window_specification
+;
+
+/// expect column (named column), or parenthesis list columns, or expression (named expression), or list expression
+ordinary_grouping_set: named_expr;
+ordinary_grouping_set_list: ordinary_grouping_set (COMMA ordinary_grouping_set)*;
+
+rollup_list: ROLLUP LPAREN ordinary_grouping_set_list RPAREN;
+cube_list: CUBE LPAREN ordinary_grouping_set_list RPAREN;
+
+/// SQL2003 grouping_set_list == grouping_element_list
+grouping_sets_specification: GROUPING SETS LPAREN grouping_element_list RPAREN;
+
+hopping_window_specification: HOP LPAREN expr COMMA expr COMMA expr COMMA expr RPAREN;
+
+result_column:
+    opt_id_prefix ASTERISK
+  | expr (AS an_id_or_type | an_id_as_compat)?
+;
+
+join_source: ANY? flatten_source (join_op ANY? flatten_source join_constraint?)*;
+
+named_column: column_name (AS an_id)?;
+
+flatten_by_arg:
+    named_column
+  | LPAREN named_expr_list COMMA? RPAREN
+;
+
+flatten_source: named_single_source (FLATTEN ((OPTIONAL|LIST|DICT)? BY flatten_by_arg | COLUMNS))?;
+
+named_single_source: single_source row_pattern_recognition_clause? ((AS an_id | an_id_as_compat) pure_column_list?)? (sample_clause | tablesample_clause)?;
+
+single_source:
+    table_ref
+  | LPAREN select_stmt RPAREN
+  | LPAREN values_stmt RPAREN
+;
+
+sample_clause: SAMPLE expr;
+
+tablesample_clause: TABLESAMPLE sampling_mode LPAREN expr RPAREN repeatable_clause?;
+
+sampling_mode: (BERNOULLI | SYSTEM);
+
+repeatable_clause: REPEATABLE LPAREN expr RPAREN;
+
+join_op:
+    COMMA
+  | (NATURAL)? ((LEFT (ONLY | SEMI)? | RIGHT (ONLY | SEMI)? | EXCLUSION | FULL)? (OUTER)? | INNER | CROSS) JOIN
+;
+
+join_constraint:
+    ON expr
+  | USING pure_column_or_named_list
+;
+
+returning_columns_list: RETURNING (ASTERISK | an_id (COMMA an_id)*);
+
+into_table_stmt: (INSERT | INSERT OR ABORT | INSERT OR REVERT | INSERT OR IGNORE | UPSERT | REPLACE) INTO into_simple_table_ref into_values_source returning_columns_list?;
+
+into_values_source:
+    pure_column_list? values_source
+  | DEFAULT VALUES
+;
+
+values_stmt: VALUES values_source_row_list;
+
+values_source: values_stmt | select_stmt;
+values_source_row_list: values_source_row (COMMA values_source_row)*;
+values_source_row: LPAREN expr_list RPAREN;
+
+simple_values_source: expr_list | select_stmt;
+
+create_external_data_source_stmt: CREATE (OR REPLACE)? EXTERNAL DATA SOURCE (IF NOT EXISTS)? object_ref
+    with_table_settings
+;
+
+alter_external_data_source_stmt: ALTER EXTERNAL DATA SOURCE object_ref
+    alter_external_data_source_action (COMMA alter_external_data_source_action)*
+;
+alter_external_data_source_action:
+    alter_table_set_table_setting_uncompat
+  | alter_table_set_table_setting_compat
+  | alter_table_reset_table_setting
+//| alter_table_rename_to // TODO
+;
+
+drop_external_data_source_stmt: DROP EXTERNAL DATA SOURCE (IF EXISTS)? object_ref;
+
+create_view_stmt: CREATE VIEW object_ref
+    with_table_settings
+    AS select_stmt
+;
+
+drop_view_stmt: DROP VIEW object_ref;
+
+upsert_object_stmt: UPSERT OBJECT object_ref
+    LPAREN TYPE object_type_ref RPAREN
+    create_object_features?
+;
+create_object_stmt: CREATE OBJECT (IF NOT EXISTS)? object_ref
+    LPAREN TYPE object_type_ref RPAREN
+    create_object_features?
+;
+create_object_features: WITH object_features;
+
+alter_object_stmt: ALTER OBJECT object_ref
+    LPAREN TYPE object_type_ref RPAREN
+    alter_object_features
+;
+alter_object_features: SET object_features;
+
+drop_object_stmt: DROP OBJECT (IF EXISTS)? object_ref
+    LPAREN TYPE object_type_ref RPAREN
+    drop_object_features?
+;
+drop_object_features: WITH object_features;
+
+object_feature_value: id_or_type | bind_parameter | STRING_VALUE;
+object_feature_kv: an_id_or_type EQUALS object_feature_value;
+object_feature_flag: an_id_or_type;
+object_feature: object_feature_kv | object_feature_flag;
+object_features: object_feature | LPAREN object_feature (COMMA object_feature)* RPAREN;
+
+object_type_ref: an_id_or_type;
+
+create_table_stmt: CREATE (OR REPLACE)? (TABLE | TABLESTORE | EXTERNAL TABLE | TEMP TABLE | TEMPORARY TABLE) (IF NOT EXISTS)? simple_table_ref LPAREN create_table_entry (COMMA create_table_entry)* COMMA? RPAREN
+    table_inherits?
+    table_partition_by?
+    with_table_settings?
+    table_tablestore?
+    table_as_source?;
+create_table_entry:
+    column_schema
+  | table_constraint
+  | table_index
+  | family_entry
+  | changefeed
+  | an_id_schema
+;
+
+create_backup_collection_stmt: CREATE backup_collection WITH LPAREN backup_collection_settings RPAREN;
+alter_backup_collection_stmt: ALTER backup_collection alter_backup_collection_actions;
+drop_backup_collection_stmt: DROP backup_collection;
+
+alter_backup_collection_actions: alter_backup_collection_action (COMMA alter_backup_collection_action)*;
+alter_backup_collection_action:
+    alter_table_set_table_setting_compat
+  | alter_table_reset_table_setting
+;
+backup_collection: BACKUP COLLECTION object_ref;
+backup_collection_settings: backup_collection_settings_entry (COMMA backup_collection_settings_entry)*;
+backup_collection_settings_entry: an_id EQUALS table_setting_value;
+
+table_inherits: INHERITS LPAREN simple_table_ref_core (COMMA simple_table_ref_core)* RPAREN;
+table_partition_by: PARTITION BY HASH pure_column_list;
+with_table_settings: WITH LPAREN table_settings_entry (COMMA table_settings_entry)* RPAREN;
+table_tablestore: TABLESTORE simple_table_ref_core;
+table_settings_entry: an_id EQUALS table_setting_value;
+table_as_source: AS values_source;
+
+alter_table_stmt: ALTER TABLE simple_table_ref alter_table_action (COMMA alter_table_action)*;
+alter_table_action:
+    alter_table_add_column
+  | alter_table_drop_column
+  | alter_table_alter_column
+  | alter_table_add_column_family
+  | alter_table_alter_column_family
+  | alter_table_set_table_setting_uncompat
+  | alter_table_set_table_setting_compat
+  | alter_table_reset_table_setting
+  | alter_table_add_index
+  | alter_table_drop_index
+  | alter_table_rename_to
+  | alter_table_add_changefeed
+  | alter_table_alter_changefeed
+  | alter_table_drop_changefeed
+  | alter_table_rename_index_to
+  | alter_table_alter_index
+  | alter_table_alter_column_drop_not_null
+;
+
+alter_external_table_stmt: ALTER EXTERNAL TABLE simple_table_ref alter_external_table_action (COMMA alter_external_table_action)*;
+alter_external_table_action:
+    alter_table_add_column
+  | alter_table_drop_column
+  | alter_table_set_table_setting_uncompat
+  | alter_table_set_table_setting_compat
+  | alter_table_reset_table_setting
+//| alter_table_rename_to // TODO
+;
+
+alter_table_store_stmt: ALTER TABLESTORE object_ref alter_table_store_action (COMMA alter_table_store_action)*;
+alter_table_store_action:
+    alter_table_add_column
+  | alter_table_drop_column
+;
+
+alter_table_add_column: ADD COLUMN? column_schema;
+alter_table_drop_column: DROP COLUMN? an_id;
+alter_table_alter_column: ALTER COLUMN an_id SET family_relation;
+alter_table_alter_column_drop_not_null: ALTER COLUMN an_id DROP NOT NULL;
+alter_table_add_column_family: ADD family_entry;
+alter_table_alter_column_family: ALTER FAMILY an_id SET an_id family_setting_value;
+alter_table_set_table_setting_uncompat: SET an_id table_setting_value;
+alter_table_set_table_setting_compat: SET LPAREN alter_table_setting_entry (COMMA alter_table_setting_entry)* RPAREN;
+alter_table_reset_table_setting: RESET LPAREN an_id (COMMA an_id)* RPAREN;
+alter_table_add_index: ADD table_index;
+alter_table_drop_index: DROP INDEX an_id;
+alter_table_rename_to: RENAME TO an_id_table;
+alter_table_rename_index_to: RENAME INDEX an_id TO an_id;
+alter_table_add_changefeed: ADD changefeed;
+alter_table_alter_changefeed: ALTER CHANGEFEED an_id changefeed_alter_settings;
+alter_table_drop_changefeed: DROP CHANGEFEED an_id;
+alter_table_alter_index: ALTER INDEX an_id alter_table_alter_index_action;
+
+column_schema: an_id_schema type_name_or_bind family_relation? opt_column_constraints;
+family_relation: FAMILY an_id;
+opt_column_constraints: (NOT? NULL)? (DEFAULT expr)?;
+column_order_by_specification: an_id (ASC | DESC)?;
+
+table_constraint:
+    PRIMARY KEY LPAREN an_id (COMMA an_id)* RPAREN
+  | PARTITION BY LPAREN an_id (COMMA an_id)* RPAREN
+  | ORDER BY LPAREN column_order_by_specification (COMMA column_order_by_specification)* RPAREN
+;
+
+table_index: INDEX an_id table_index_type
+    ON LPAREN an_id_schema (COMMA an_id_schema)* RPAREN
+    (COVER LPAREN an_id_schema (COMMA an_id_schema)* RPAREN)?
+    with_index_settings?
+;
+
+table_index_type: (global_index | local_index) (USING index_subtype)?;
+
+global_index: GLOBAL UNIQUE? (SYNC | ASYNC)?;
+local_index: LOCAL;
+
+index_subtype: an_id;
+
+with_index_settings: WITH LPAREN index_setting_entry (COMMA index_setting_entry)* COMMA? RPAREN; 
+index_setting_entry: an_id EQUALS index_setting_value;
+index_setting_value:
+      id_or_type
+    | STRING_VALUE      
+    | integer
+    | bool_value
+;
+
+changefeed: CHANGEFEED an_id WITH LPAREN changefeed_settings RPAREN;
+changefeed_settings: changefeed_settings_entry (COMMA changefeed_settings_entry)*;
+changefeed_settings_entry: an_id EQUALS changefeed_setting_value;
+changefeed_setting_value: expr;
+changefeed_alter_settings:
+    DISABLE
+  | SET LPAREN changefeed_settings RPAREN
+;
+
+alter_table_setting_entry: an_id EQUALS table_setting_value;
+
+table_setting_value:
+      id
+    | STRING_VALUE
+    | integer
+    | split_boundaries
+    | expr ON an_id (AS (SECONDS | MILLISECONDS | MICROSECONDS | NANOSECONDS))?
+    | bool_value
+;
+
+family_entry: FAMILY an_id family_settings;
+family_settings: LPAREN (family_settings_entry (COMMA family_settings_entry)*)? RPAREN;
+family_settings_entry: an_id EQUALS family_setting_value;
+family_setting_value: STRING_VALUE;
+
+split_boundaries:
+      LPAREN literal_value_list (COMMA literal_value_list)* RPAREN
+    | literal_value_list
+;
+
+literal_value_list: LPAREN literal_value (COMMA literal_value)* RPAREN;
+
+alter_table_alter_index_action:
+    alter_table_set_table_setting_uncompat
+  | alter_table_set_table_setting_compat
+  | alter_table_reset_table_setting
+;
+
+drop_table_stmt: DROP (TABLE | TABLESTORE | EXTERNAL TABLE) (IF EXISTS)? simple_table_ref;
+
+create_user_stmt: CREATE USER role_name create_user_option?;
+alter_user_stmt: ALTER USER role_name (WITH? create_user_option | RENAME TO role_name);
+
+create_group_stmt: CREATE GROUP role_name (WITH USER role_name (COMMA role_name)* COMMA?)?;
+alter_group_stmt: ALTER GROUP role_name ((ADD|DROP) USER role_name (COMMA role_name)* COMMA? | RENAME TO role_name);
+
+drop_role_stmt: DROP (USER|GROUP) (IF EXISTS)? role_name (COMMA role_name)* COMMA?;
+
+role_name: an_id_or_type | bind_parameter;
+create_user_option: ENCRYPTED? PASSWORD expr;
+
+grant_permissions_stmt: GRANT permission_name_target ON an_id_schema (COMMA an_id_schema)* TO role_name (COMMA role_name)* COMMA? (WITH GRANT OPTION)?;
+revoke_permissions_stmt: REVOKE (GRANT OPTION FOR)? permission_name_target ON an_id_schema (COMMA an_id_schema)* FROM role_name (COMMA role_name)*;
+
+permission_id:
+      CONNECT
+    | LIST
+    | INSERT
+    | MANAGE
+    | DROP
+    | GRANT
+    | MODIFY (TABLES | ATTRIBUTES)
+    | (UPDATE | ERASE) ROW
+    | (REMOVE | DESCRIBE | ALTER) SCHEMA
+    | SELECT (TABLES | ATTRIBUTES | ROW)?
+    | (USE | FULL) LEGACY?
+    | CREATE (DIRECTORY | TABLE | QUEUE)?
+;
+
+permission_name: permission_id | STRING_VALUE;
+
+permission_name_target: permission_name (COMMA permission_name)* COMMA? | ALL PRIVILEGES?;
+
+create_resource_pool_stmt: CREATE RESOURCE POOL object_ref
+  with_table_settings
+;
+
+alter_resource_pool_stmt: ALTER RESOURCE POOL object_ref
+  alter_resource_pool_action (COMMA alter_resource_pool_action)*
+;
+alter_resource_pool_action:
+    alter_table_set_table_setting_compat
+  | alter_table_reset_table_setting
+;
+
+drop_resource_pool_stmt: DROP RESOURCE POOL object_ref;
+
+create_resource_pool_classifier_stmt: CREATE RESOURCE POOL CLASSIFIER object_ref
+  with_table_settings
+;
+
+alter_resource_pool_classifier_stmt: ALTER RESOURCE POOL CLASSIFIER object_ref
+  alter_resource_pool_classifier_action (COMMA alter_resource_pool_classifier_action)*
+;
+alter_resource_pool_classifier_action:
+    alter_table_set_table_setting_compat
+  | alter_table_reset_table_setting
+;
+
+drop_resource_pool_classifier_stmt: DROP RESOURCE POOL CLASSIFIER object_ref;
+
+create_replication_stmt: CREATE ASYNC REPLICATION object_ref
+    FOR replication_target (COMMA replication_target)*
+    WITH LPAREN replication_settings RPAREN
+;
+
+replication_target: object_ref AS object_ref;
+replication_settings: replication_settings_entry (COMMA replication_settings_entry)*;
+replication_settings_entry: an_id EQUALS STRING_VALUE;
+
+alter_replication_stmt: ALTER ASYNC REPLICATION object_ref alter_replication_action (COMMA alter_replication_action)*;
+alter_replication_action:
+    alter_replication_set_setting
+;
+
+alter_replication_set_setting: SET LPAREN replication_settings RPAREN;
+
+drop_replication_stmt: DROP ASYNC REPLICATION object_ref CASCADE?;
+
+action_or_subquery_args: opt_bind_parameter (COMMA opt_bind_parameter)*;
+
+define_action_or_subquery_stmt: DEFINE (ACTION|SUBQUERY) bind_parameter LPAREN action_or_subquery_args? RPAREN AS define_action_or_subquery_body END DEFINE;
+define_action_or_subquery_body: SEMICOLON* (sql_stmt_core (SEMICOLON+ sql_stmt_core)* SEMICOLON*)?;
+
+if_stmt: EVALUATE? IF expr do_stmt (ELSE do_stmt)?;
+for_stmt: EVALUATE? PARALLEL? FOR bind_parameter IN expr do_stmt (ELSE do_stmt)?;
+
+table_ref: (cluster_expr DOT)? AT? (table_key | an_id_expr LPAREN (table_arg (COMMA table_arg)* COMMA?)? RPAREN | bind_parameter (LPAREN expr_list? RPAREN)? (VIEW view_name)?) table_hints?;
+
+table_key: id_table_or_type (VIEW view_name)?;
+table_arg: AT? named_expr (VIEW view_name)?;
+table_hints: WITH (table_hint | LPAREN table_hint (COMMA table_hint)* RPAREN);
+table_hint:
+      an_id_hint (EQUALS (type_name_tag | LPAREN type_name_tag (COMMA type_name_tag)* COMMA? RPAREN))?
+    | (SCHEMA | COLUMNS) EQUALS? type_name_or_bind
+    | SCHEMA EQUALS? LPAREN (struct_arg_positional (COMMA struct_arg_positional)*)? COMMA? RPAREN
+;
+
+object_ref: (cluster_expr DOT)? id_or_at;
+simple_table_ref_core: object_ref | AT? bind_parameter;
+simple_table_ref: simple_table_ref_core table_hints?;
+into_simple_table_ref: simple_table_ref (ERASE BY pure_column_list)?;
+
+delete_stmt: DELETE FROM simple_table_ref (WHERE expr | ON into_values_source)? returning_columns_list?;
+update_stmt: UPDATE simple_table_ref (SET set_clause_choice (WHERE expr)? | ON into_values_source)  returning_columns_list?;
+
+/// out of 2003 standart
+set_clause_choice: set_clause_list | multiple_column_assignment;
+
+set_clause_list: set_clause (COMMA set_clause)*;
+set_clause: set_target EQUALS expr;
+set_target: column_name;
+multiple_column_assignment: set_target_list EQUALS LPAREN simple_values_source RPAREN;
+set_target_list: LPAREN set_target (COMMA set_target)* RPAREN;
+
+// topics
+create_topic_stmt: CREATE TOPIC (IF NOT EXISTS)? topic_ref create_topic_entries? with_topic_settings?;
+
+create_topic_entries: LPAREN create_topic_entry (COMMA create_topic_entry)* RPAREN;
+create_topic_entry:
+    topic_create_consumer_entry
+;
+with_topic_settings: WITH LPAREN topic_settings RPAREN;
+
+alter_topic_stmt: ALTER TOPIC (IF EXISTS)? topic_ref alter_topic_action (COMMA alter_topic_action)*;
+alter_topic_action:
+    alter_topic_add_consumer
+  | alter_topic_alter_consumer
+  | alter_topic_drop_consumer
+  | alter_topic_set_settings
+  | alter_topic_reset_settings
+;
+
+alter_topic_add_consumer: ADD topic_create_consumer_entry;
+topic_create_consumer_entry: CONSUMER an_id topic_consumer_with_settings?;
+
+alter_topic_alter_consumer: ALTER CONSUMER topic_consumer_ref alter_topic_alter_consumer_entry;
+alter_topic_alter_consumer_entry:
+    topic_alter_consumer_set
+  | topic_alter_consumer_reset
+;
+
+alter_topic_drop_consumer: DROP CONSUMER topic_consumer_ref;
+
+topic_alter_consumer_set: SET LPAREN topic_consumer_settings RPAREN;
+topic_alter_consumer_reset: RESET LPAREN an_id (COMMA an_id)* RPAREN;
+
+alter_topic_set_settings: SET LPAREN topic_settings RPAREN;
+alter_topic_reset_settings: RESET LPAREN an_id (COMMA an_id_pure)* RPAREN;
+
+drop_topic_stmt: DROP TOPIC (IF EXISTS)? topic_ref;
+
+topic_settings: topic_settings_entry (COMMA topic_settings_entry)*;
+topic_settings_entry: an_id EQUALS topic_setting_value;
+topic_setting_value:
+    expr
+;
+
+topic_consumer_with_settings: WITH LPAREN topic_consumer_settings RPAREN;
+topic_consumer_settings: topic_consumer_settings_entry (COMMA topic_consumer_settings_entry)*;
+topic_consumer_settings_entry: an_id EQUALS topic_consumer_setting_value;
+topic_consumer_setting_value:
+    expr
+;
+
+topic_ref: (cluster_expr DOT)? an_id;
+topic_consumer_ref: an_id_pure;
+
+/// window function supp
+// differ from 2003 for resolve conflict
+null_treatment: RESPECT NULLS | IGNORE NULLS;
+
+filter_clause: FILTER LPAREN WHERE expr RPAREN;
+
+window_name_or_specification: window_name | window_specification;
+
+window_name: an_id_window;
+
+window_clause: WINDOW window_definition_list;
+
+window_definition_list: window_definition (COMMA window_definition)*;
+
+window_definition: new_window_name AS window_specification;
+
+new_window_name: window_name;
+
+window_specification: LPAREN window_specification_details RPAREN;
+
+window_specification_details:
+    existing_window_name?
+    window_partition_clause?
+    window_order_clause?
+    window_frame_clause?
+;
+
+existing_window_name: window_name;
+window_partition_clause: PARTITION COMPACT? BY named_expr_list;
+window_order_clause: order_by_clause;
+
+window_frame_clause: window_frame_units window_frame_extent window_frame_exclusion?;
+window_frame_units: ROWS | RANGE | GROUPS;
+
+window_frame_extent: window_frame_bound | window_frame_between;
+
+window_frame_between: BETWEEN window_frame_bound AND window_frame_bound;
+
+window_frame_bound:
+    CURRENT ROW
+  | (expr | UNBOUNDED) (PRECEDING | FOLLOWING)
+;
+
+window_frame_exclusion: EXCLUDE CURRENT ROW | EXCLUDE GROUP | EXCLUDE TIES | EXCLUDE NO OTHERS;
+
+// EXTRAS
+use_stmt: USE cluster_expr;
+
+subselect_stmt: (LPAREN select_stmt RPAREN | select_unparenthesized_stmt);
+
+// TODO: [fatal] rule named_nodes_stmt has non-LL(*) decision due to recursive rule invocations reachable from alts 1,3
+// named_nodes_stmt: bind_parameter_list EQUALS (expr | subselect_stmt | values_stmt | LPAREN values_stmt RPAREN);
+named_nodes_stmt: bind_parameter_list EQUALS (expr | subselect_stmt);
+
+commit_stmt: COMMIT;
+
+rollback_stmt: ROLLBACK;
+
+analyze_table: simple_table_ref (LPAREN column_list RPAREN)?;
+analyze_table_list: analyze_table (COMMA analyze_table)* COMMA?;
+analyze_stmt: ANALYZE analyze_table_list;
+
+// Special rules that allow to use certain keywords as identifiers.
+identifier: ID_PLAIN | ID_QUOTED;
+id: identifier | keyword;
+
+id_schema:
+    identifier
+  | keyword_compat
+  | keyword_expr_uncompat
+//  | keyword_table_uncompat
+  | keyword_select_uncompat
+//  | keyword_alter_uncompat
+  | keyword_in_uncompat
+  | keyword_window_uncompat
+  | keyword_hint_uncompat
+;
+
+id_expr:
+    identifier
+  | keyword_compat
+//  | keyword_expr_uncompat
+//  | keyword_table_uncompat
+//  | keyword_select_uncompat
+  | keyword_alter_uncompat
+  | keyword_in_uncompat
+  | keyword_window_uncompat
+  | keyword_hint_uncompat
+;
+
+id_expr_in:
+    identifier
+  | keyword_compat
+//  | keyword_expr_uncompat
+//  | keyword_table_uncompat
+//  | keyword_select_uncompat
+  | keyword_alter_uncompat
+//  | keyword_in_uncompat
+  | keyword_window_uncompat
+  | keyword_hint_uncompat
+;
+
+id_window:
+    identifier
+  | keyword_compat
+  | keyword_expr_uncompat
+  | keyword_table_uncompat
+  | keyword_select_uncompat
+  | keyword_alter_uncompat
+  | keyword_in_uncompat
+//  | keyword_window_uncompat
+  | keyword_hint_uncompat
+;
+
+id_table:
+    identifier
+  | keyword_compat
+  | keyword_expr_uncompat
+//  | keyword_table_uncompat
+  | keyword_select_uncompat
+//  | keyword_alter_uncompat
+  | keyword_in_uncompat
+  | keyword_window_uncompat
+  | keyword_hint_uncompat
+;
+
+id_without:
+    identifier
+  | keyword_compat
+//  | keyword_expr_uncompat
+  | keyword_table_uncompat
+//  | keyword_select_uncompat
+  | keyword_alter_uncompat
+  | keyword_in_uncompat
+  | keyword_window_uncompat
+  | keyword_hint_uncompat
+;
+
+id_hint:
+    identifier
+  | keyword_compat
+  | keyword_expr_uncompat
+  | keyword_table_uncompat
+  | keyword_select_uncompat
+  | keyword_alter_uncompat
+  | keyword_in_uncompat
+  | keyword_window_uncompat
+//  | keyword_hint_uncompat
+;
+
+id_as_compat: identifier | keyword_as_compat;
+
+// ANSI-aware versions of various identifiers with support double-quoted identifiers when PRAGMA AnsiQuotedIdentifiers; is present
+an_id: id | STRING_VALUE;
+an_id_or_type: id_or_type | STRING_VALUE;
+an_id_schema: id_schema | STRING_VALUE;
+an_id_expr: id_expr | STRING_VALUE;
+an_id_expr_in: id_expr_in | STRING_VALUE;
+an_id_window: id_window | STRING_VALUE;
+an_id_table: id_table | STRING_VALUE;
+an_id_without: id_without | STRING_VALUE;
+an_id_hint: id_hint | STRING_VALUE;
+an_id_pure: identifier | STRING_VALUE;
+an_id_as_compat: id_as_compat | STRING_VALUE;
+
+view_name: an_id | PRIMARY KEY;
+
+opt_id_prefix: (an_id DOT)?;
+cluster_expr: (an_id COLON)? (pure_column_or_named | ASTERISK);
+
+id_or_type: id | type_id;
+opt_id_prefix_or_type: (an_id_or_type DOT)?;
+id_or_at: AT? an_id_or_type;
+id_table_or_type: an_id_table | type_id;
+id_table_or_at: AT? id_table_or_type;
+
+keyword:
+    keyword_compat
+  | keyword_expr_uncompat
+  | keyword_table_uncompat
+  | keyword_select_uncompat
+  | keyword_alter_uncompat
+  | keyword_in_uncompat
+  | keyword_window_uncompat
+  | keyword_hint_uncompat
+;
+
+keyword_expr_uncompat:
+    ASYMMETRIC
+  | BETWEEN
+  | BITCAST
+  | CASE
+  | CAST
+  | CUBE
+  | CURRENT_DATE
+  | CURRENT_TIME
+  | CURRENT_TIMESTAMP
+  | EMPTY_ACTION
+  | EXISTS
+  | FROM
+  | FULL
+  | HOP
+  | JSON_EXISTS
+  | JSON_VALUE
+  | JSON_QUERY
+  | LOCAL
+  | NOT
+  | NULL
+  | PROCESS
+  | REDUCE
+  | RETURN
+  | RETURNING
+  | ROLLUP
+  | SELECT
+  | SYMMETRIC
+  | UNBOUNDED
+  | WHEN
+  | WHERE
+;
+
+keyword_table_uncompat:
+    ANY
+  | ERASE
+  | STREAM
+;
+
+keyword_select_uncompat:
+    ALL
+  | AS
+  | ASSUME
+  | DISTINCT
+  | EXCEPT
+  | HAVING
+  | INTERSECT
+  | LIMIT
+  | UNION
+  | WINDOW
+  | WITHOUT
+;
+
+keyword_alter_uncompat:
+    COLUMN
+;
+
+keyword_in_uncompat:
+    COMPACT
+;
+
+keyword_window_uncompat:
+    GROUPS
+  | RANGE
+  | ROWS
+;
+
+keyword_hint_uncompat:
+    SCHEMA
+  | COLUMNS
+;
+
+keyword_as_compat:
+    ABORT
+  | ACTION
+  | ADD
+  | AFTER
+  | ALTER
+  | ANALYZE
+  | AND
+  | ANSI
+  | ARRAY
+  | ASC
+  | ASYNC
+  | ATTACH
+  | ATTRIBUTES
+  | AUTOINCREMENT
+  | BACKUP
+  | BEFORE
+  | BEGIN
+  | BERNOULLI
+  | BY
+  | CASCADE
+  | CHANGEFEED
+  | CHECK
+  | CLASSIFIER
+  // | COLLATE
+  | COLLECTION
+  | COMMIT
+  | CONDITIONAL
+  | CONFLICT
+  | CONNECT
+  | CONSTRAINT
+  | CONSUMER
+  | COVER
+  | CREATE
+  // | CROSS
+  | CURRENT
+  | DATA
+  | DATABASE
+  | DECIMAL
+  | DECLARE
+  | DEFAULT
+  | DEFERRABLE
+  | DEFERRED
+  // | DEFINE
+  | DELETE
+  | DESC
+  | DESCRIBE
+  | DETACH
+  | DIRECTORY
+  | DISABLE
+  | DISCARD
+  // | DO
+  | DROP
+  | EACH
+  | ELSE
+  | EMPTY
+  | ENCRYPTED
+  | END
+  | ERROR
+  | ESCAPE
+  | EVALUATE
+  | EXCLUDE
+  // | EXCLUSION
+  | EXCLUSIVE
+  | EXPLAIN
+  | EXPORT
+  | EXTERNAL
+  | FAIL
+  | FAMILY
+  | FILTER
+  | FIRST
+  | FLATTEN
+  | FOLLOWING
+  | FOR
+  | FOREIGN
+  | FUNCTION
+  | GLOB
+  | GRANT
+  | GROUP
+  | GROUPING
+  | HASH
+  | IF
+  | IGNORE
+  | ILIKE
+  | IMMEDIATE
+  | IMPORT
+  | IN
+  | INDEX
+  | INDEXED
+  | INHERITS
+  | INITIAL
+  | INITIALLY
+  // | INNER
+  | INSERT
+  | INSTEAD
+  | INTO
+  | IS
+  // | ISNULL
+  // | JOIN
+  // | KEY
+  | LAST
+  // | LEFT
+  | LEGACY
+  | LIKE
+  | MANAGE
+  | MATCH
+  | MATCHES
+  | MATCH_RECOGNIZE
+  | MEASURES
+  | MICROSECONDS
+  | MILLISECONDS
+  | MODIFY
+  | NANOSECONDS
+  // | NATURAL
+  | NEXT
+  | NO
+  // | NOTNULL
+  | NULLS
+  | OBJECT
+  | OF
+  | OFFSET
+  | OMIT
+  // | ON
+  | ONE
+  | ONLY
+  | OPTION
+  | OR
+  | ORDER
+  | OTHERS
+  // | OUTER
+  // | OVER
+  | PARALLEL
+  | PARTITION
+  | PASSING
+  | PASSWORD
+  | PAST
+  | PATTERN
+  | PER
+  | PERMUTE
+  | PLAN
+  | POOL
+  | PRAGMA
+  | PRECEDING
+  // | PRESORT
+  | PRIMARY
+  | PRIVILEGES
+//  | QUERY
+  | QUEUE
+  | RAISE
+//  | READ
+  | REFERENCES
+  | REGEXP
+  | REINDEX
+  | RELEASE
+  | REMOVE
+  | RENAME
+  | REPLACE
+  | REPLICATION
+  | RESET
+  | RESPECT
+  | RESTRICT
+  // | RESULT
+  | REVERT
+  | REVOKE
+  // | RIGHT
+  | RLIKE
+  | ROLLBACK
+  | ROW
+  // | SAMPLE
+  | SAVEPOINT
+  | SECONDS
+  | SEEK
+  // | SEMI
+  | SETS
+  | SHOW
+  | TSKIP
+  | SOURCE
+  | SUBQUERY
+  | SUBSET
+  | SYMBOLS
+  | SYNC
+  | SYSTEM
+  | TABLE
+  | TABLES
+  | TABLESAMPLE
+  | TABLESTORE
+  | TEMP
+  | TEMPORARY
+  | THEN
+  | TIES
+  | TO
+  | TOPIC
+  | TRANSACTION
+  | TRIGGER
+  | TYPE
+  | UNCONDITIONAL
+  | UNIQUE
+  | UNKNOWN
+  | UNMATCHED
+  | UPDATE
+  | UPSERT
+  | USE
+  | USER
+//  | USING
+  | VACUUM
+  | VALUES
+//  | VIEW
+  | VIRTUAL
+//  | WITH
+  | WRAPPER
+//  | WRITE
+  | XOR
+;
+
+// insert new keyword into keyword_as_compat also
+keyword_compat: (
+    ABORT
+  | ACTION
+  | ADD
+  | AFTER
+  | ALTER
+  | ANALYZE
+  | AND
+  | ANSI
+  | ARRAY
+  | ASC
+  | ASYNC
+  | ATTACH
+  | ATTRIBUTES
+  | AUTOINCREMENT
+  | BACKUP
+  | BEFORE
+  | BEGIN
+  | BERNOULLI
+  | BY
+  | CASCADE
+  | CHANGEFEED
+  | CHECK
+  | CLASSIFIER
+  | COLLATE
+  | COLLECTION
+  | COMMIT
+  | CONDITIONAL
+  | CONFLICT
+  | CONNECT
+  | CONSTRAINT
+  | CONSUMER
+  | COVER
+  | CREATE
+  | CROSS
+  | CURRENT
+  | DATA
+  | DATABASE
+  | DECIMAL
+  | DECLARE
+  | DEFAULT
+  | DEFERRABLE
+  | DEFERRED
+  | DEFINE
+  | DELETE
+  | DESC
+  | DESCRIBE
+  | DETACH
+  | DIRECTORY
+  | DISABLE
+  | DISCARD
+  | DO
+  | DROP
+  | EACH
+  | ELSE
+  | EMPTY
+  | ENCRYPTED
+  | END
+  | ERROR
+  | ESCAPE
+  | EVALUATE
+  | EXCLUDE
+  | EXCLUSION
+  | EXCLUSIVE
+  | EXPLAIN
+  | EXPORT
+  | EXTERNAL
+  | FAIL
+  | FAMILY
+  | FILTER
+  | FIRST
+  | FLATTEN
+  | FOLLOWING
+  | FOR
+  | FOREIGN
+  | FUNCTION
+  | GLOB
+  | GRANT
+  | GROUP
+  | GROUPING
+  | HASH
+  | IF
+  | IGNORE
+  | ILIKE
+  | IMMEDIATE
+  | IMPORT
+  | IN
+  | INDEX
+  | INDEXED
+  | INHERITS
+  | INITIAL
+  | INITIALLY
+  | INNER
+  | INSERT
+  | INSTEAD
+  | INTO
+  | IS
+  | ISNULL
+  | JOIN
+  | KEY
+  | LAST
+  | LEFT
+  | LEGACY
+  | LIKE
+  | MANAGE
+  | MATCH
+  | MATCHES
+  | MATCH_RECOGNIZE
+  | MEASURES
+  | MICROSECONDS
+  | MILLISECONDS
+  | MODIFY
+  | NANOSECONDS
+  | NATURAL
+  | NEXT
+  | NO
+  | NOTNULL
+  | NULLS
+  | OBJECT
+  | OF
+  | OFFSET
+  | OMIT
+  | ON
+  | ONE
+  | ONLY
+  | OPTION
+  | OR
+  | ORDER
+  | OTHERS
+  | OUTER
+  | OVER
+  | PARALLEL
+  | PARTITION
+  | PASSING
+  | PASSWORD
+  | PAST
+  | PATTERN
+  | PER
+  | PERMUTE
+  | PLAN
+  | POOL
+  | PRAGMA
+  | PRECEDING
+  | PRESORT
+  | PRIMARY
+  | PRIVILEGES
+//  | QUERY
+  | QUEUE
+  | RAISE
+//  | READ
+  | REFERENCES
+  | REGEXP
+  | REINDEX
+  | RELEASE
+  | REMOVE
+  | RENAME
+  | REPLACE
+  | REPLICATION
+  | RESET
+  | RESPECT
+  | RESTRICT
+  | RESULT
+  | REVERT
+  | REVOKE
+  | RIGHT
+  | RLIKE
+  | ROLLBACK
+  | ROW
+  | SAMPLE
+  | SAVEPOINT
+  | SECONDS
+  | SEEK
+  | SEMI
+  | SETS
+  | SHOW
+  | TSKIP
+  | SOURCE
+  | SUBQUERY
+  | SUBSET
+  | SYMBOLS
+  | SYNC
+  | SYSTEM
+  | TABLE
+  | TABLES
+  | TABLESAMPLE
+  | TABLESTORE
+  | TEMP
+  | TEMPORARY
+  | THEN
+  | TIES
+  | TO
+  | TOPIC
+  | TRANSACTION
+  | TRIGGER
+  | TYPE
+  | UNCONDITIONAL
+  | UNIQUE
+  | UNKNOWN
+  | UNMATCHED
+  | UPDATE
+  | UPSERT
+  | USE
+  | USER
+  | USING
+  | VACUUM
+  | VALUES
+  | VIEW
+  | VIRTUAL
+  | WITH
+  | WRAPPER
+//  | WRITE
+  | XOR
+  );
+
+type_id:
+    OPTIONAL
+  | TUPLE
+  | STRUCT
+  | VARIANT
+  | LIST
+//  | STREAM
+  | FLOW
+  | DICT
+  | SET
+  | ENUM
+  | RESOURCE
+  | TAGGED
+  | CALLABLE
+;
+
+bool_value: (TRUE | FALSE);
+real: REAL;
+integer: DIGITS | INTEGER_VALUE;
+
+//
+// Lexer
+//
+
+EQUALS:        '=';
+EQUALS2:       '==';
+NOT_EQUALS:    '!=';
+NOT_EQUALS2:   '<>';
+LESS:          '<';
+LESS_OR_EQ:    '<=';
+GREATER:       '>';
+GREATER_OR_EQ: '>=';
+SHIFT_LEFT:    '<<';
+ROT_LEFT:      '|<<';
+AMPERSAND:     '&';
+PIPE:          '|';
+DOUBLE_PIPE:   '||';
+STRUCT_OPEN:   '<|';
+STRUCT_CLOSE:  '|>';
+PLUS:          '+';
+MINUS:         '-';
+TILDA:         '~';
+ASTERISK:      '*';
+SLASH:         '/';
+BACKSLASH:     '\\';
+PERCENT:       '%';
+SEMICOLON:     ';';
+DOT:           '.';
+COMMA:         ',';
+LPAREN:        '(';
+RPAREN:        ')';
+QUESTION:      '?';
+COLON:         ':';
+AT:            '@';
+DOUBLE_AT:     '@@';
+DOLLAR:        '$';
+QUOTE_DOUBLE:  '"'; // This comment for fix syntax highlighting "
+QUOTE_SINGLE:  '\'';
+BACKTICK:      '`';
+LBRACE_CURLY:  '{';
+RBRACE_CURLY:  '}';
+CARET:         '^';
+NAMESPACE:     '::';
+ARROW:         '->';
+RBRACE_SQUARE: ']';
+LBRACE_SQUARE: '['; // pair ]
+
+// http://www.antlr.org/wiki/pages/viewpage.action?pageId=1782
+fragment A:('a'|'A');
+fragment B:('b'|'B');
+fragment C:('c'|'C');
+fragment D:('d'|'D');
+fragment E:('e'|'E');
+fragment F:('f'|'F');
+fragment G:('g'|'G');
+fragment H:('h'|'H');
+fragment I:('i'|'I');
+fragment J:('j'|'J');
+fragment K:('k'|'K');
+fragment L:('l'|'L');
+fragment M:('m'|'M');
+fragment N:('n'|'N');
+fragment O:('o'|'O');
+fragment P:('p'|'P');
+fragment Q:('q'|'Q');
+fragment R:('r'|'R');
+fragment S:('s'|'S');
+fragment T:('t'|'T');
+fragment U:('u'|'U');
+fragment V:('v'|'V');
+fragment W:('w'|'W');
+fragment X:('x'|'X');
+fragment Y:('y'|'Y');
+fragment Z:('z'|'Z');
+
+ABORT: A B O R T;
+ACTION: A C T I O N;
+ADD: A D D;
+AFTER: A F T E R;
+ALL: A L L;
+ALTER: A L T E R;
+ANALYZE: A N A L Y Z E;
+AND: A N D;
+ANSI: A N S I;
+ANY: A N Y;
+ARRAY: A R R A Y;
+AS: A S;
+ASC: A S C;
+ASSUME: A S S U M E;
+ASYMMETRIC: A S Y M M E T R I C;
+ASYNC: A S Y N C;
+ATTACH: A T T A C H;
+ATTRIBUTES: A T T R I B U T E S;
+AUTOINCREMENT: A U T O I N C R E M E N T;
+AUTOMAP: A U T O M A P;
+BACKUP: B A C K U P;
+COLLECTION: C O L L E C T I O N;
+BEFORE: B E F O R E;
+BEGIN: B E G I N;
+BERNOULLI: B E R N O U L L I;
+BETWEEN: B E T W E E N;
+BITCAST: B I T C A S T;
+BY: B Y;
+CALLABLE: C A L L A B L E;
+CASCADE: C A S C A D E;
+CASE: C A S E;
+CAST: C A S T;
+CHANGEFEED: C H A N G E F E E D;
+CHECK: C H E C K;
+CLASSIFIER: C L A S S I F I E R;
+COLLATE: C O L L A T E;
+COLUMN: C O L U M N;
+COLUMNS: C O L U M N S;
+COMMIT: C O M M I T;
+COMPACT: C O M P A C T;
+CONDITIONAL: C O N D I T I O N A L;
+CONFLICT: C O N F L I C T;
+CONNECT: C O N N E C T;
+CONSTRAINT: C O N S T R A I N T;
+CONSUMER: C O N S U M E R;
+COVER: C O V E R;
+CREATE: C R E A T E;
+CROSS: C R O S S;
+CUBE: C U B E;
+CURRENT: C U R R E N T;
+CURRENT_DATE: C U R R E N T '_' D A T E;
+CURRENT_TIME: C U R R E N T '_' T I M E;
+CURRENT_TIMESTAMP: C U R R E N T '_' T I M E S T A M P;
+DATA: D A T A;
+DATABASE: D A T A B A S E;
+DECIMAL: D E C I M A L;
+DECLARE: D E C L A R E;
+DEFAULT: D E F A U L T;
+DEFERRABLE: D E F E R R A B L E;
+DEFERRED: D E F E R R E D;
+DEFINE: D E F I N E;
+DELETE: D E L E T E;
+DESC: D E S C;
+DESCRIBE: D E S C R I B E;
+DETACH: D E T A C H;
+DICT: D I C T;
+DIRECTORY: D I R E C T O R Y;
+DISABLE: D I S A B L E;
+DISCARD: D I S C A R D;
+DISTINCT: D I S T I N C T;
+DO: D O;
+DROP: D R O P;
+// TODO: fix sql formatter and drop EACH
+EACH: E A C H;
+ELSE: E L S E;
+EMPTY: E M P T Y;
+EMPTY_ACTION: E M P T Y '_' A C T I O N;
+ENCRYPTED: E N C R Y P T E D;
+END: E N D;
+ENUM: E N U M;
+ERASE: E R A S E;
+ERROR: E R R O R;
+ESCAPE: E S C A P E;
+EVALUATE: E V A L U A T E;
+EXCEPT: E X C E P T;
+EXCLUDE: E X C L U D E;
+EXCLUSION: E X C L U S I O N;
+EXCLUSIVE: E X C L U S I V E;
+EXISTS: E X I S T S;
+EXPLAIN: E X P L A I N;
+EXPORT: E X P O R T;
+EXTERNAL: E X T E R N A L;
+FAIL: F A I L;
+FALSE: F A L S E;
+FAMILY: F A M I L Y;
+FILTER: F I L T E R;
+FIRST: F I R S T;
+FLATTEN: F L A T T E N;
+FLOW: F L O W;
+FOLLOWING: F O L L O W I N G;
+FOR: F O R;
+FOREIGN: F O R E I G N;
+FROM: F R O M;
+FULL: F U L L;
+FUNCTION: F U N C T I O N;
+GLOB: G L O B;
+GLOBAL: G L O B A L;
+GRANT: G R A N T;
+GROUP: G R O U P;
+GROUPING: G R O U P I N G;
+GROUPS: G R O U P S;
+HASH: H A S H;
+HAVING: H A V I N G;
+HOP: H O P;
+IF: I F;
+IGNORE: I G N O R E;
+ILIKE: I L I K E;
+IMMEDIATE: I M M E D I A T E;
+IMPORT: I M P O R T;
+IN: I N;
+INDEX: I N D E X;
+INDEXED: I N D E X E D;
+INHERITS: I N H E R I T S;
+INITIAL: I N I T I A L;
+INITIALLY: I N I T I A L L Y;
+INNER: I N N E R;
+INSERT: I N S E R T;
+INSTEAD: I N S T E A D;
+INTERSECT: I N T E R S E C T;
+INTO: I N T O;
+IS: I S;
+ISNULL: I S N U L L;
+JOIN: J O I N;
+JSON_EXISTS: J S O N '_' E X I S T S;
+JSON_QUERY: J S O N '_' Q U E R Y;
+JSON_VALUE: J S O N '_' V A L U E;
+KEY: K E Y;
+LAST: L A S T;
+LEFT: L E F T;
+LEGACY: L E G A C Y;
+LIKE: L I K E;
+LIMIT: L I M I T;
+LIST: L I S T;
+LOCAL: L O C A L;
+MANAGE: M A N A G E;
+MATCH: M A T C H;
+MATCHES: M A T C H E S;
+MATCH_RECOGNIZE: M A T C H '_' R E C O G N I Z E;
+MEASURES: M E A S U R E S;
+MICROSECONDS: M I C R O S E C O N D S;
+MILLISECONDS: M I L L I S E C O N D S;
+MODIFY: M O D I F Y;
+NANOSECONDS: N A N O S E C O N D S;
+NATURAL: N A T U R A L;
+NEXT: N E X T;
+NO: N O;
+NOT: N O T;
+NOTNULL: N O T N U L L;
+NULL: N U L L;
+NULLS: N U L L S;
+OBJECT: O B J E C T;
+OF: O F;
+OFFSET: O F F S E T;
+OMIT: O M I T;
+ON: O N;
+ONE: O N E;
+ONLY: O N L Y;
+OPTION: O P T I O N;
+OPTIONAL: O P T I O N A L;
+OR: O R;
+ORDER: O R D E R;
+OTHERS: O T H E R S;
+OUTER: O U T E R;
+OVER: O V E R;
+PARALLEL: P A R A L L E L;
+PARTITION: P A R T I T I O N;
+PASSING: P A S S I N G;
+PASSWORD: P A S S W O R D;
+PAST: P A S T;
+PATTERN: P A T T E R N;
+PER: P E R;
+PERMUTE: P E R M U T E;
+PLAN: P L A N;
+POOL: P O O L;
+PRAGMA: P R A G M A;
+PRECEDING: P R E C E D I N G;
+PRESORT: P R E S O R T;
+PRIMARY: P R I M A R Y;
+PRIVILEGES: P R I V I L E G E S;
+PROCESS: P R O C E S S;
+//QUERY: Q U E R Y;
+QUEUE: Q U E U E;
+RAISE: R A I S E;
+RANGE: R A N G E;
+//READ: R E A D;
+REDUCE: R E D U C E;
+REFERENCES: R E F E R E N C E S;
+REGEXP: R E G E X P;
+REINDEX: R E I N D E X;
+RELEASE: R E L E A S E;
+REMOVE: R E M O V E;
+RENAME: R E N A M E;
+REPEATABLE: R E P E A T A B L E;
+REPLACE: R E P L A C E;
+REPLICATION: R E P L I C A T I O N;
+RESET: R E S E T;
+RESOURCE: R E S O U R C E;
+RESPECT: R E S P E C T;
+RESTRICT: R E S T R I C T;
+RESULT: R E S U L T;
+RETURN: R E T U R N;
+RETURNING: R E T U R N I N G;
+REVERT: R E V E R T;
+REVOKE: R E V O K E;
+RIGHT: R I G H T;
+RLIKE: R L I K E;
+ROLLBACK: R O L L B A C K;
+ROLLUP: R O L L U P;
+ROW: R O W;
+ROWS: R O W S;
+SAMPLE: S A M P L E;
+SAVEPOINT: S A V E P O I N T;
+SCHEMA: S C H E M A;
+SECONDS: S E C O N D S;
+SEEK: S E E K;
+SELECT: S E L E C T;
+SEMI: S E M I;
+SET: S E T;
+SETS: S E T S;
+SHOW: S H O W;
+TSKIP: S K I P;
+SOURCE: S O U R C E;
+STREAM: S T R E A M;
+STRUCT: S T R U C T;
+SUBQUERY: S U B Q U E R Y;
+SUBSET: S U B S E T;
+SYMBOLS: S Y M B O L S;
+SYMMETRIC: S Y M M E T R I C;
+SYNC: S Y N C;
+SYSTEM: S Y S T E M;
+TABLE: T A B L E;
+TABLES: T A B L E S;
+TABLESAMPLE: T A B L E S A M P L E;
+TABLESTORE: T A B L E S T O R E;
+TAGGED: T A G G E D;
+TEMP: T E M P;
+TEMPORARY: T E M P O R A R Y;
+THEN: T H E N;
+TIES: T I E S;
+TO: T O;
+TOPIC: T O P I C;
+TRANSACTION: T R A N S A C T I O N;
+TRIGGER: T R I G G E R;
+TRUE: T R U E;
+TUPLE: T U P L E;
+TYPE: T Y P E;
+UNBOUNDED: U N B O U N D E D;
+UNCONDITIONAL: U N C O N D I T I O N A L;
+UNION: U N I O N;
+UNIQUE: U N I Q U E;
+UNKNOWN: U N K N O W N;
+UNMATCHED: U N M A T C H E D;
+UPDATE: U P D A T E;
+UPSERT: U P S E R T;
+USE: U S E;
+USER: U S E R;
+USING: U S I N G;
+VACUUM: V A C U U M;
+VALUES: V A L U E S;
+VARIANT: V A R I A N T;
+VIEW: V I E W;
+VIRTUAL: V I R T U A L;
+WHEN: W H E N;
+WHERE: W H E R E;
+WINDOW: W I N D O W;
+WITH: W I T H;
+WITHOUT: W I T H O U T;
+WRAPPER: W R A P P E R;
+//WRITE: W R I T E;
+XOR: X O R;
+
+// YQL Default Lexer:
+// GRAMMAR_STRING_CORE_SINGLE = ~(QUOTE_SINGLE | BACKSLASH) | (BACKSLASH .)
+// GRAMMAR_STRING_CORE_DOUBLE = ~(QUOTE_DOUBLE | BACKSLASH) | (BACKSLASH .)
+
+// ANSI Lexer:
+// GRAMMAR_STRING_CORE_SINGLE = ~QUOTE_SINGLE | (QUOTE_SINGLE QUOTE_SINGLE)
+// GRAMMAR_STRING_CORE_DOUBLE = ~QUOTE_DOUBLE | (QUOTE_DOUBLE QUOTE_DOUBLE)
+
+fragment STRING_CORE_SINGLE: @GRAMMAR_STRING_CORE_SINGLE@;
+fragment STRING_CORE_DOUBLE: @GRAMMAR_STRING_CORE_DOUBLE@;
+
+fragment STRING_SINGLE: (QUOTE_SINGLE STRING_CORE_SINGLE* QUOTE_SINGLE);
+fragment STRING_DOUBLE: (QUOTE_DOUBLE STRING_CORE_DOUBLE* QUOTE_DOUBLE);
+fragment STRING_MULTILINE: (DOUBLE_AT .*? DOUBLE_AT)+ AT?;
+
+STRING_VALUE: ((STRING_SINGLE | STRING_DOUBLE | STRING_MULTILINE) (S | U | Y | J | P (T | B | V)?)?);
+
+ID_PLAIN: ('a'..'z' | 'A'..'Z' | '_') ('a'..'z' | 'A'..'Z' | '_' | DIGIT)*;
+
+fragment ID_QUOTED_CORE: '``' | '\\`' | ~'`';
+ID_QUOTED: BACKTICK ID_QUOTED_CORE* BACKTICK;
+
+fragment DIGIT: '0'..'9';
+fragment HEXDIGIT: '0'..'9' | 'a'..'f' | 'A'..'F';
+fragment HEXDIGITS: '0' X HEXDIGIT+;
+fragment OCTDIGITS: '0' O ('0'..'8')+;
+fragment BINDIGITS: '0' B ('0' | '1')+;
+fragment DECDIGITS: DIGIT+;
+DIGITS: DECDIGITS | HEXDIGITS | OCTDIGITS | BINDIGITS;
+
+// not all combinations of P/U with L/S/T/I/B/N are actually valid - this is resolved in sql.cpp
+INTEGER_VALUE: DIGITS ((P | U)? (L | S | T | I | B | N)?);
+
+fragment FLOAT_EXP : E (PLUS | MINUS)? DECDIGITS ;
+REAL:
+    (
+        DECDIGITS DOT DIGIT* FLOAT_EXP?
+    |   DECDIGITS FLOAT_EXP
+//  |   DOT DECDIGITS FLOAT_EXP?    // Conflicts with tuple element access through DOT
+    ) (F | P (F ('4'|'8') | N)?)?
+    ;
+
+BLOB: X QUOTE_SINGLE HEXDIGIT+ QUOTE_SINGLE;
+
+TQ:('q'|'Q');
+TU:('u'|'U');
+TE:('e'|'E');
+TR:('r'|'R');
+TY:('y'|'Y');
+
+// YQL Default Lexer:
+// GRAMMAR_MULTILINE_COMMENT_CORE = .
+// ANSI Lexer:
+// GRAMMAR_MULTILINE_COMMENT_CORE = MULTILINE_COMMENT | .
+
+fragment MULTILINE_COMMENT: '/*' ( @GRAMMAR_MULTILINE_COMMENT_CORE@ )*? '*/';
+fragment LINE_COMMENT: '--' ~('\n'|'\r')* ('\r' '\n'? | '\n' | EOF);
+WS: (' '|'\r'|'\t'|'\u000C'|'\n')->channel(HIDDEN);
+COMMENT: (MULTILINE_COMMENT|LINE_COMMENT)->channel(HIDDEN);
diff --git a/ydb/library/yql/sql/v1/context.h b/ydb/library/yql/sql/v1/context.h
index e75018ccbcd0..fcb7644615dd 100644
--- a/ydb/library/yql/sql/v1/context.h
+++ b/ydb/library/yql/sql/v1/context.h
@@ -18,6 +18,10 @@
 #include <util/generic/deque.h>
 #include <util/generic/vector.h>
 
+#define ANTLR3_TOKEN(NAME) SQLv1LexerTokens::TOKEN_##NAME << 16
+#define ANTLR4_TOKEN(NAME) (SQLv1Antlr4Lexer::TOKEN_##NAME << 16) + 1
+#define IS_TOKEN(ID, NAME) (UnifiedToken(ID) == ANTLR3_TOKEN(NAME) || UnifiedToken(ID) == ANTLR4_TOKEN(NAME))
+
 namespace NSQLTranslationV1 {
     inline bool IsAnonymousName(const TString& name) {
         return name == "$_";
@@ -27,6 +31,7 @@ namespace NSQLTranslationV1 {
         return service == NYql::RtmrProviderName || service == NYql::PqProviderName;
     }
 
+
     struct TNodeWithUsageInfo : public TThrRefBase {
         explicit TNodeWithUsageInfo(const TNodePtr& node, TPosition namePos, int level)
             : Node(node)
@@ -374,6 +379,10 @@ namespace NSQLTranslationV1 {
             return Ctx.Token(token);
         }
 
+        uint UnifiedToken(uint id) const {
+            return Ctx.Settings.Antlr4Parser + (id << 16);
+        }
+
         TString Identifier(const NSQLv1Generated::TToken& token) {
             return IdContent(Ctx, Token(token));
         }
diff --git a/ydb/library/yql/sql/v1/format/sql_format.cpp b/ydb/library/yql/sql/v1/format/sql_format.cpp
index 88a35bd7bd95..810e63577510 100644
--- a/ydb/library/yql/sql/v1/format/sql_format.cpp
+++ b/ydb/library/yql/sql/v1/format/sql_format.cpp
@@ -2872,7 +2872,7 @@ class TSqlFormatter : public NSQLFormat::ISqlFormatter {
         }
 
         if (mode == EFormatMode::Obfuscate) {
-            auto message = NSQLTranslationV1::SqlAST(query, "Query", issues, NSQLTranslation::SQL_MAX_PARSER_ERRORS, parsedSettings.AnsiLexer, parsedSettings.Arena);
+            auto message = NSQLTranslationV1::SqlAST(query, "Query", issues, NSQLTranslation::SQL_MAX_PARSER_ERRORS, parsedSettings.AnsiLexer, parsedSettings.Antlr4Parser, parsedSettings.Arena);
             if (!message) {
                 return false;
             }
@@ -2881,7 +2881,7 @@ class TSqlFormatter : public NSQLFormat::ISqlFormatter {
             return Format(visitor.Process(*message), formattedQuery, issues, EFormatMode::Pretty);
         }
 
-        auto lexer = NSQLTranslationV1::MakeLexer(parsedSettings.AnsiLexer);
+        auto lexer = NSQLTranslationV1::MakeLexer(parsedSettings.AnsiLexer, parsedSettings.Antlr4Parser);
         TParsedTokenList allTokens;
         auto onNextToken = [&](NSQLTranslation::TParsedToken&& token) {
             if (token.Name != "EOF") {
@@ -2935,7 +2935,7 @@ class TSqlFormatter : public NSQLFormat::ISqlFormatter {
             }
 
             NYql::TIssues parserIssues;
-            auto message = NSQLTranslationV1::SqlAST(currentQuery, "Query", parserIssues, NSQLTranslation::SQL_MAX_PARSER_ERRORS, parsedSettings.AnsiLexer, parsedSettings.Arena);
+            auto message = NSQLTranslationV1::SqlAST(currentQuery, "Query", parserIssues, NSQLTranslation::SQL_MAX_PARSER_ERRORS, parsedSettings.AnsiLexer, parsedSettings.Antlr4Parser, parsedSettings.Arena);
             if (!message) {
                 finalFormattedQuery << currentQuery;
                 if (!currentQuery.EndsWith("\n")) {
@@ -2998,7 +2998,7 @@ TString MutateQuery(const TString& query, const NSQLTranslation::TTranslationSet
         throw yexception() << issues.ToString();
     }
 
-    auto lexer = NSQLTranslationV1::MakeLexer(parsedSettings.AnsiLexer);
+    auto lexer = NSQLTranslationV1::MakeLexer(parsedSettings.AnsiLexer, parsedSettings.Antlr4Parser);
     TVector<NSQLTranslation::TParsedToken> allTokens;
     auto onNextToken = [&](NSQLTranslation::TParsedToken&& token) {
         if (token.Name != "EOF") {
@@ -3042,6 +3042,7 @@ bool SqlFormatSimple(const TString& query, TString& formattedQuery, TString& err
 
 THashSet<TString> GetKeywords() {
     TString grammar;
+    // ANTLR4-MIGRATION: just change SQLv1 to SQLv1Antlr4
     Y_ENSURE(NResource::FindExact("SQLv1.g.in", &grammar));
     THashSet<TString> res;
     TVector<TString> lines;
diff --git a/ydb/library/yql/sql/v1/format/sql_format_ut.cpp b/ydb/library/yql/sql/v1/format/sql_format_ut.cpp
index fedbf0dd625b..3aa3a27c9a78 100644
--- a/ydb/library/yql/sql/v1/format/sql_format_ut.cpp
+++ b/ydb/library/yql/sql/v1/format/sql_format_ut.cpp
@@ -16,7 +16,7 @@ struct TSetup {
         settings.Arena = &Arena;
         Formatter = NSQLFormat::MakeSqlFormatter(settings);
     }
-
+    
     void Run(const TCases& cases, NSQLFormat::EFormatMode mode = NSQLFormat::EFormatMode::Pretty) {
         for (const auto& c : cases) {
             NYql::TIssues issues;
@@ -47,1622 +47,5 @@ struct TSetup {
 }
 
 Y_UNIT_TEST_SUITE(CheckSqlFormatter) {
-    Y_UNIT_TEST(Pragma) {
-        TCases cases = {
-            {"pragma user = user;","PRAGMA user = user;\n"},
-            {"pragma user = default;","PRAGMA user = default;\n"},
-            {"pragma user.user = user;","PRAGMA user.user = user;\n"},
-            {"pragma user.user(user);","PRAGMA user.user(user);\n"},
-            {"pragma user.user(user, user);","PRAGMA user.user(user, user);\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(DotAfterDigits) {
-        TCases cases = {
-            {"select a.1 .b from plato.foo;","SELECT\n\ta.1 .b\nFROM plato.foo;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(GrantPermissions) {
-        TCases cases {
-            {"use plato;grant connect, modify tables, list on `/Root` to user;", "USE plato;\n\nGRANT CONNECT, MODIFY TABLES, LIST ON `/Root` TO user;\n"},
-            {"use plato;grant select , select tables, select attributes on `/Root` to user;", "USE plato;\n\nGRANT SELECT, SELECT TABLES, SELECT ATTRIBUTES ON `/Root` TO user;\n"},
-            {"use plato;grant insert, modify attributes on `/Root` to user;", "USE plato;\n\nGRANT INSERT, MODIFY ATTRIBUTES ON `/Root` TO user;\n"},
-            {"use plato;grant use legacy, use on `/Root` to user1, user2;", "USE plato;\n\nGRANT USE LEGACY, USE ON `/Root` TO user1, user2;\n"},
-            {"use plato;grant manage, full legacy, full, create on `/Root` to user;", "USE plato;\n\nGRANT MANAGE, FULL LEGACY, FULL, CREATE ON `/Root` TO user;\n"},
-            {"use plato;grant drop, grant, select row, update row on `/Root` to user;", "USE plato;\n\nGRANT DROP, GRANT, SELECT ROW, UPDATE ROW ON `/Root` TO user;\n"},
-            {"use plato;grant erase row, create directory on `/Root` to user;", "USE plato;\n\nGRANT ERASE ROW, CREATE DIRECTORY ON `/Root` TO user;\n"},
-            {"use plato;grant create table, create queue, remove schema on `/Root` to user;", "USE plato;\n\nGRANT CREATE TABLE, CREATE QUEUE, REMOVE SCHEMA ON `/Root` TO user;\n"},
-            {"use plato;grant describe schema, alter schema on `/Root` to user;", "USE plato;\n\nGRANT DESCRIBE SCHEMA, ALTER SCHEMA ON `/Root` TO user;\n"},
-            {"use plato;grant select, on `/Root` to user, with grant option;", "USE plato;\n\nGRANT SELECT, ON `/Root` TO user, WITH GRANT OPTION;\n"},
-            {"use plato;grant all privileges on `/Root` to user;", "USE plato;\n\nGRANT ALL PRIVILEGES ON `/Root` TO user;\n"},
-            {"use plato;grant list on `/Root/db1`, `/Root/db2` to user;", "USE plato;\n\nGRANT LIST ON `/Root/db1`, `/Root/db2` TO user;\n"}
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(RevokePermissions) {
-        TCases cases {
-            {"use plato;revoke connect, modify tables, list on `/Root` from user;", "USE plato;\n\nREVOKE CONNECT, MODIFY TABLES, LIST ON `/Root` FROM user;\n"},
-            {"use plato;revoke select , select tables, select attributes on `/Root` from user;", "USE plato;\n\nREVOKE SELECT, SELECT TABLES, SELECT ATTRIBUTES ON `/Root` FROM user;\n"},
-            {"use plato;revoke insert, modify attributes on `/Root` from user;", "USE plato;\n\nREVOKE INSERT, MODIFY ATTRIBUTES ON `/Root` FROM user;\n"},
-            {"use plato;revoke use legacy, use on `/Root` from user1, user2;", "USE plato;\n\nREVOKE USE LEGACY, USE ON `/Root` FROM user1, user2;\n"},
-            {"use plato;revoke manage, full legacy, full, create on `/Root` from user;", "USE plato;\n\nREVOKE MANAGE, FULL LEGACY, FULL, CREATE ON `/Root` FROM user;\n"},
-            {"use plato;revoke drop, grant, select row, update row on `/Root` from user;", "USE plato;\n\nREVOKE DROP, GRANT, SELECT ROW, UPDATE ROW ON `/Root` FROM user;\n"},
-            {"use plato;revoke erase row, create directory on `/Root` from user;", "USE plato;\n\nREVOKE ERASE ROW, CREATE DIRECTORY ON `/Root` FROM user;\n"},
-            {"use plato;revoke create table, create queue, remove schema on `/Root` from user;", "USE plato;\n\nREVOKE CREATE TABLE, CREATE QUEUE, REMOVE SCHEMA ON `/Root` FROM user;\n"},
-            {"use plato;revoke describe schema, alter schema on `/Root` from user;", "USE plato;\n\nREVOKE DESCRIBE SCHEMA, ALTER SCHEMA ON `/Root` FROM user;\n"},
-            {"use plato;revoke grant option for insert, on `/Root` from user;", "USE plato;\n\nREVOKE GRANT OPTION FOR INSERT, ON `/Root` FROM user;\n"},
-            {"use plato;revoke all privileges on `/Root` from user;", "USE plato;\n\nREVOKE ALL PRIVILEGES ON `/Root` FROM user;\n"},
-            {"use plato;revoke list on `/Root/db1`, `/Root/db2` from user;", "USE plato;\n\nREVOKE LIST ON `/Root/db1`, `/Root/db2` FROM user;\n"}
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(DropRole) {
-        TCases cases = {
-            {"use plato;drop user user,user,user;","USE plato;\n\nDROP USER user, user, user;\n"},
-            {"use plato;drop group if exists user;","USE plato;\n\nDROP GROUP IF EXISTS user;\n"},
-            {"use plato;drop group user,;","USE plato;\n\nDROP GROUP user,;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(CreateUser) {
-        TCases cases = {
-            {"use plato;create user user;","USE plato;\n\nCREATE USER user;\n"},
-            {"use plato;create user user encrypted password 'foo';","USE plato;\n\nCREATE USER user ENCRYPTED PASSWORD 'foo';\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(CreateGroup) {
-        TCases cases = {
-            {"use plato;create group user;","USE plato;\n\nCREATE GROUP user;\n"},
-            {"use plato;create group user with user user;","USE plato;\n\nCREATE GROUP user WITH USER user;\n"},
-            {"use plato;create group user with user user, user,;","USE plato;\n\nCREATE GROUP user WITH USER user, user,;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(AlterUser) {
-        TCases cases = {
-            {"use plato;alter user user rename to user;","USE plato;\n\nALTER USER user RENAME TO user;\n"},
-            {"use plato;alter user user encrypted password 'foo';","USE plato;\n\nALTER USER user ENCRYPTED PASSWORD 'foo';\n"},
-            {"use plato;alter user user with encrypted password 'foo';","USE plato;\n\nALTER USER user WITH ENCRYPTED PASSWORD 'foo';\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(AlterGroup) {
-        TCases cases = {
-            {"use plato;alter group user add user user;","USE plato;\n\nALTER GROUP user ADD USER user;\n"},
-            {"use plato;alter group user drop user user;","USE plato;\n\nALTER GROUP user DROP USER user;\n"},
-            {"use plato;alter group user add user user, user,;","USE plato;\n\nALTER GROUP user ADD USER user, user,;\n"},
-            {"use plato;alter group user rename to user;","USE plato;\n\nALTER GROUP user RENAME TO user;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(Use) {
-        TCases cases = {
-            {"use user;","USE user;\n"},
-            {"use user:user;","USE user: user;\n"},
-            {"use user:*;","USE user: *;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(Commit) {
-        TCases cases = {
-            {"commit;","COMMIT;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(Rollback) {
-        TCases cases = {
-            {"rollback;","ROLLBACK;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(Export) {
-        TCases cases = {
-            {"export $foo;","EXPORT $foo;\n"},
-            {"export $foo, $bar;","EXPORT $foo, $bar;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(Import) {
-        TCases cases = {
-            {"import user symbols $foo;","IMPORT user SYMBOLS $foo;\n"},
-            {"import user symbols $foo,$bar;","IMPORT user SYMBOLS $foo, $bar;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(Values) {
-        TCases cases = {
-            {"values (1);","VALUES\n\t(1);\n"},
-            {"values (1,2),(3,4);","VALUES\n\t(1, 2),\n\t(3, 4);\n"},
-            {"values ('a\nb');","VALUES\n\t('a\nb');\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(Declare) {
-        TCases cases = {
-            {"declare $foo as int32;","DECLARE $foo AS int32;\n"},
-            {"declare $foo as bool ?","DECLARE $foo AS bool?;\n"},
-            {"declare $foo as bool ? ?","DECLARE $foo AS bool??;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(NamedNode) {
-        TCases cases = {
-            {"$x=1","$x = 1;\n"},
-            {"$x,$y=(2,3)","$x, $y = (2, 3);\n"},
-            {"$a = select 1 union all select 2","$a =\n\tSELECT\n\t\t1\n\tUNION ALL\n\tSELECT\n\t\t2;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(DropTable) {
-        TCases cases = {
-            {"drop table user","DROP TABLE user;\n"},
-            {"drop table if exists user","DROP TABLE IF EXISTS user;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(CreateTable) {
-        TCases cases = {
-            {"create table user(user int32)","CREATE TABLE user (\n\tuser int32\n);\n"},
-            {"create table user(user int32,user bool ?)","CREATE TABLE user (\n\tuser int32,\n\tuser bool?\n);\n"},
-            {"create table user(user int32) with (user=user)","CREATE TABLE user (\n\tuser int32\n)\nWITH (user = user);\n"},
-            {"create table user(primary key (user))","CREATE TABLE user (\n\tPRIMARY KEY (user)\n);\n"},
-            {"create table user(primary key (user,user))","CREATE TABLE user (\n\tPRIMARY KEY (user, user)\n);\n"},
-            {"create table user(partition by (user))","CREATE TABLE user (\n\tPARTITION BY (user)\n);\n"},
-            {"create table user(partition by (user,user))","CREATE TABLE user (\n\tPARTITION BY (user, user)\n);\n"},
-            {"create table user(order by (user asc))","CREATE TABLE user (\n\tORDER BY (user ASC)\n);\n"},
-            {"create table user(order by (user desc,user))","CREATE TABLE user (\n\tORDER BY (user DESC, user)\n);\n"},
-            {"create table user(user int32) with (ttl=interval('P1D') on user as seconds)",
-             "CREATE TABLE user (\n\tuser int32\n)\nWITH (ttl = interval('P1D') ON user AS SECONDS);\n"},
-            {"create table user(user int32) with (ttl=interval('P1D') on user as MilliSeconds)",
-             "CREATE TABLE user (\n\tuser int32\n)\nWITH (ttl = interval('P1D') ON user AS MILLISECONDS);\n"},
-            {"create table user(user int32) with (ttl=interval('P1D') on user as microSeconds)",
-             "CREATE TABLE user (\n\tuser int32\n)\nWITH (ttl = interval('P1D') ON user AS MICROSECONDS);\n"},
-            {"create table user(user int32) with (ttl=interval('P1D') on user as nAnOsEcOnDs)",
-             "CREATE TABLE user (\n\tuser int32\n)\nWITH (ttl = interval('P1D') ON user AS NANOSECONDS);\n"},
-            {"create table user(index user global unique sync on (user,user) with (user=user,user=user))",
-             "CREATE TABLE user (\n\tINDEX user GLOBAL UNIQUE SYNC ON (user, user) WITH (user = user, user = user)\n);\n"},
-            {"create table user(index user global async on (user) with (user=user,))",
-             "CREATE TABLE user (\n\tINDEX user GLOBAL ASYNC ON (user) WITH (user = user,)\n);\n"},
-            {"create table user(index user local on (user) cover (user))",
-             "CREATE TABLE user (\n\tINDEX user LOCAL ON (user) COVER (user)\n);\n"},
-            {"create table user(index user local on (user) cover (user,user))",
-             "CREATE TABLE user (\n\tINDEX user LOCAL ON (user) COVER (user, user)\n);\n"},
-            {"create table user(index idx global using subtype on (col) cover (col) with (setting = foo, another_setting = bar));",
-             "CREATE TABLE user (\n\tINDEX idx GLOBAL USING subtype ON (col) COVER (col) WITH (setting = foo, another_setting = bar)\n);\n"},
-            {"create table user(family user (user='foo'))",
-             "CREATE TABLE user (\n\tFAMILY user (user = 'foo')\n);\n"},
-            {"create table user(family user (user='foo',user='bar'))",
-             "CREATE TABLE user (\n\tFAMILY user (user = 'foo', user = 'bar')\n);\n"},
-            {"create table user(changefeed user with (user='foo'))",
-             "CREATE TABLE user (\n\tCHANGEFEED user WITH (user = 'foo')\n);\n"},
-            {"create table user(changefeed user with (user='foo',user='bar'))",
-             "CREATE TABLE user (\n\tCHANGEFEED user WITH (user = 'foo', user = 'bar')\n);\n"},
-            {"create table user(user) AS SELECT 1","CREATE TABLE user (\n\tuser\n)\nAS\nSELECT\n    1;\n"},
-            {"create table user(user) AS VALUES (1), (2)","CREATE TABLE user (\n\tuser\n)\nAS\nVALUES\n    (1),\n    (2);\n"},
-            {"create table user(foo int32, bar bool ?) inherits (s3:$cluster.xxx) partition by hash(a,b,hash) with (inherits=interval('PT1D') ON logical_time) tablestore tablestore",
-              "CREATE TABLE user (\n"
-              "\tfoo int32,\n"
-              "\tbar bool?\n"
-              ")\n"
-              "INHERITS (s3: $cluster.xxx)\n"
-              "PARTITION BY HASH (a, b, hash)\n"
-              "WITH (inherits = interval('PT1D') ON logical_time)\n"
-              "TABLESTORE tablestore;\n"},
-            {"create table user(foo int32, bar bool ?) partition by hash(a,b,hash) with (tiering='some')",
-              "CREATE TABLE user (\n"
-              "\tfoo int32,\n"
-              "\tbar bool?\n"
-              ")\n"
-              "PARTITION BY HASH (a, b, hash)\n"
-              "WITH (tiering = 'some');\n"},
-            {"create table if not  exists user(user int32)", "CREATE TABLE IF NOT EXISTS user (\n\tuser int32\n);\n"},
-            {"create temp   table    user(user int32)", "CREATE TEMP TABLE user (\n\tuser int32\n);\n"},
-            {"create   temporary   table    user(user int32)", "CREATE TEMPORARY TABLE user (\n\tuser int32\n);\n"}
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(ObjectOperations) {
-        TCases cases = {
-            {"alter oBject usEr (TYpe abcde) Set (a = b)",
-             "ALTER OBJECT usEr (TYPE abcde) SET (a = b);\n"},
-            {"creAte oBject usEr (tYpe abcde) With (a = b)",
-             "CREATE OBJECT usEr (TYPE abcde) WITH (a = b);\n"},
-             {"creAte oBject if not exIstS usEr (tYpe abcde) With (a = b)",
-             "CREATE OBJECT IF NOT EXISTS usEr (TYPE abcde) WITH (a = b);\n"},
-            {"creAte oBject usEr (tYpe abcde) With a = b",
-             "CREATE OBJECT usEr (TYPE abcde) WITH a = b;\n"},
-            {"dRop oBject usEr (tYpe abcde) With (aeEE)",
-             "DROP OBJECT usEr (TYPE abcde) WITH (aeEE);\n"},
-             {"dRop oBject If ExistS usEr (tYpe abcde) With (aeEE)",
-             "DROP OBJECT IF EXISTS usEr (TYPE abcde) WITH (aeEE);\n"},
-            {"dRop oBject usEr (tYpe abcde) With aeEE",
-             "DROP OBJECT usEr (TYPE abcde) WITH aeEE;\n"}
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(TableStoreOperations) {
-        TCases cases = {
-            {"alter tableStore uSer aDd column usEr int32",
-             "ALTER TABLESTORE uSer ADD COLUMN usEr int32;\n"},
-             {"alter tableStore uSer drOp column usEr",
-             "ALTER TABLESTORE uSer DROP COLUMN usEr;\n"}
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(ExternalDataSourceOperations) {
-        TCases cases = {
-            {"creAte exTernAl daTa SouRce usEr With (a = \"b\")",
-             "CREATE EXTERNAL DATA SOURCE usEr WITH (a = \"b\");\n"},
-             {"creAte exTernAl daTa SouRce if not exists usEr With (a = \"b\")",
-             "CREATE EXTERNAL DATA SOURCE IF NOT EXISTS usEr WITH (a = \"b\");\n"},
-             {"creAte oR rePlaCe exTernAl daTa SouRce usEr With (a = \"b\")",
-             "CREATE OR REPLACE EXTERNAL DATA SOURCE usEr WITH (a = \"b\");\n"},
-             {"create external data source eds with (a=\"a\",b=\"b\",c = true)",
-             "CREATE EXTERNAL DATA SOURCE eds WITH (\n\ta = \"a\",\n\tb = \"b\",\n\tc = TRUE\n);\n"},
-             {"alter external data source eds set a true, reset (b, c), set (x=y, z=false)",
-             "ALTER EXTERNAL DATA SOURCE eds\n\tSET a TRUE,\n\tRESET (b, c),\n\tSET (x = y, z = FALSE);\n"},
-             {"alter external data source eds reset (a), set (x=y)",
-             "ALTER EXTERNAL DATA SOURCE eds\n\tRESET (a),\n\tSET (x = y);\n"},
-            {"dRop exTerNal Data SouRce usEr",
-             "DROP EXTERNAL DATA SOURCE usEr;\n"},
-             {"dRop exTerNal Data SouRce if exists usEr",
-             "DROP EXTERNAL DATA SOURCE IF EXISTS usEr;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(AsyncReplication) {
-        TCases cases = {
-            {"create async replication user for table1 AS table2 with (user='foo')",
-             "CREATE ASYNC REPLICATION user FOR table1 AS table2 WITH (user = 'foo');\n"},
-            {"alter async replication user set (user='foo')",
-             "ALTER ASYNC REPLICATION user SET (user = 'foo');\n"},
-            {"drop async replication user",
-             "DROP ASYNC REPLICATION user;\n"},
-            {"drop async replication user cascade",
-             "DROP ASYNC REPLICATION user CASCADE;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(ExternalTableOperations) {
-        TCases cases = {
-            {"creAte exTernAl TabLe usEr (a int) With (a = \"b\")",
-             "CREATE EXTERNAL TABLE usEr (\n\ta int\n)\nWITH (a = \"b\");\n"},
-             {"creAte oR rePlaCe exTernAl TabLe usEr (a int) With (a = \"b\")",
-             "CREATE OR REPLACE EXTERNAL TABLE usEr (\n\ta int\n)\nWITH (a = \"b\");\n"},
-            {"creAte exTernAl TabLe iF NOt Exists usEr (a int) With (a = \"b\")",
-             "CREATE EXTERNAL TABLE IF NOT EXISTS usEr (\n\ta int\n)\nWITH (a = \"b\");\n"},
-            {"create external table user (a int) with (a=\"b\",c=\"d\")",
-             "CREATE EXTERNAL TABLE user (\n\ta int\n)\nWITH (\n\ta = \"b\",\n\tc = \"d\"\n);\n"},
-            {"alter  external table user add column col1 int32, drop column col2, reset(prop), set (prop2 = 42, x=y), set a true",
-            "ALTER EXTERNAL TABLE user\n\tADD COLUMN col1 int32,\n\tDROP COLUMN col2,\n\tRESET (prop),\n\tSET (prop2 = 42, x = y),\n\tSET a TRUE;\n"},
-            {"dRop exTerNal taBlE usEr",
-             "DROP EXTERNAL TABLE usEr;\n"},
-            {"dRop exTerNal taBlE iF eXiStS usEr",
-             "DROP EXTERNAL TABLE IF EXISTS usEr;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(TypeSelection) {
-        TCases cases = {
-            {"Select tYpe.* frOm Table tYpe",
-             "SELECT\n\ttYpe.*\nFROM Table\n\ttYpe;\n"}
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(AlterTable) {
-        TCases cases = {
-            {"alter table user add user int32",
-             "ALTER TABLE user\n\tADD user int32;\n"},
-            {"alter table user add user int32, add user bool ?",
-             "ALTER TABLE user\n\tADD user int32,\n\tADD user bool?;\n"},
-            {"alter table user add column user int32",
-             "ALTER TABLE user\n\tADD COLUMN user int32;\n"},
-            {"alter table user drop user",
-             "ALTER TABLE user\n\tDROP user;\n"},
-            {"alter table user drop column user",
-             "ALTER TABLE user\n\tDROP COLUMN user;\n"},
-            {"alter table user alter column user set family user",
-             "ALTER TABLE user\n\tALTER COLUMN user SET FAMILY user;\n"},
-            {"alter table t alter column c drop not null",
-             "ALTER TABLE t\n\tALTER COLUMN c DROP NOT NULL;\n"},
-            {"alter table user add family user(user='foo')",
-             "ALTER TABLE user\n\tADD FAMILY user (user = 'foo');\n"},
-            {"alter table user alter family user set user 'foo'",
-             "ALTER TABLE user\n\tALTER FAMILY user SET user 'foo';\n"},
-            {"alter table user set user user",
-             "ALTER TABLE user\n\tSET user user;\n"},
-            {"alter table user set (user=user)",
-             "ALTER TABLE user\n\tSET (user = user);\n"},
-            {"alter table user set (user=user,user=user)",
-             "ALTER TABLE user\n\tSET (user = user, user = user);\n"},
-            {"alter table user reset(user)",
-             "ALTER TABLE user\n\tRESET (user);\n"},
-            {"alter table user reset(user, user)",
-             "ALTER TABLE user\n\tRESET (user, user);\n"},
-            {"alter table user add index user local on (user)",
-             "ALTER TABLE user\n\tADD INDEX user LOCAL ON (user);\n"},
-            {"alter table user alter index idx set setting 'foo'",
-             "ALTER TABLE user\n\tALTER INDEX idx SET setting 'foo';\n"},
-            {"alter table user alter index idx set (setting = 'foo', another_setting = 'bar')",
-             "ALTER TABLE user\n\tALTER INDEX idx SET (setting = 'foo', another_setting = 'bar');\n"},
-            {"alter table user alter index idx reset (setting, another_setting)",
-             "ALTER TABLE user\n\tALTER INDEX idx RESET (setting, another_setting);\n"},
-            {"alter table user add index idx global using subtype on (col) cover (col) with (setting = foo, another_setting = 'bar');",
-             "ALTER TABLE user\n\tADD INDEX idx GLOBAL USING subtype ON (col) COVER (col) WITH (setting = foo, another_setting = 'bar');\n"},
-            {"alter table user drop index user",
-             "ALTER TABLE user\n\tDROP INDEX user;\n"},
-            {"alter table user rename to user",
-             "ALTER TABLE user\n\tRENAME TO user;\n"},
-            {"alter table user add changefeed user with (user = 'foo')",
-             "ALTER TABLE user\n\tADD CHANGEFEED user WITH (user = 'foo');\n"},
-            {"alter table user alter changefeed user disable",
-             "ALTER TABLE user\n\tALTER CHANGEFEED user DISABLE;\n"},
-            {"alter table user alter changefeed user set(user='foo')",
-             "ALTER TABLE user\n\tALTER CHANGEFEED user SET (user = 'foo');\n"},
-            {"alter table user drop changefeed user",
-             "ALTER TABLE user\n\tDROP CHANGEFEED user;\n"},
-            {"alter table user add changefeed user with (initial_scan = tRUe)",
-             "ALTER TABLE user\n\tADD CHANGEFEED user WITH (initial_scan = TRUE);\n"},
-            {"alter table user add changefeed user with (initial_scan = FaLsE)",
-             "ALTER TABLE user\n\tADD CHANGEFEED user WITH (initial_scan = FALSE);\n"},
-            {"alter table user add changefeed user with (retention_period = Interval(\"P1D\"))",
-             "ALTER TABLE user\n\tADD CHANGEFEED user WITH (retention_period = Interval(\"P1D\"));\n"},
-            {"alter table user add changefeed user with (virtual_timestamps = TruE)",
-             "ALTER TABLE user\n\tADD CHANGEFEED user WITH (virtual_timestamps = TRUE);\n"},
-            {"alter table user add changefeed user with (virtual_timestamps = fAlSe)",
-             "ALTER TABLE user\n\tADD CHANGEFEED user WITH (virtual_timestamps = FALSE);\n"},
-            {"alter table user add changefeed user with (resolved_timestamps = Interval(\"PT1S\"))",
-             "ALTER TABLE user\n\tADD CHANGEFEED user WITH (resolved_timestamps = Interval(\"PT1S\"));\n"},
-            {"alter table user add changefeed user with (topic_min_active_partitions = 1)",
-             "ALTER TABLE user\n\tADD CHANGEFEED user WITH (topic_min_active_partitions = 1);\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(CreateTopic) {
-        TCases cases = {
-            {"create topic topic1",
-             "CREATE TOPIC topic1;\n"},
-             {"create topic topic1 (consumer c1)",
-             "CREATE TOPIC topic1 (\n\tCONSUMER c1\n);\n"},
-             {"create topic topic1 (consumer c1, consumer c2 with (important = True))",
-             "CREATE TOPIC topic1 (\n\tCONSUMER c1,\n\tCONSUMER c2 WITH (important = TRUE)\n);\n"},
-             {"create topic topic1 (consumer c1) with (partition_count_limit = 5)",
-             "CREATE TOPIC topic1 (\n\tCONSUMER c1\n) WITH (\n\tpartition_count_limit = 5\n);\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(AlterTopic) {
-        TCases cases = {
-             {"alter topic topic1 alter consumer c1 set (important = false)",
-             "ALTER TOPIC topic1\n\tALTER CONSUMER c1 SET (important = FALSE);\n"},
-             {"alter topic topic1 alter consumer c1 set (important = false), alter consumer c2 reset (read_from)",
-              "ALTER TOPIC topic1\n\tALTER CONSUMER c1 SET (important = FALSE),\n\tALTER CONSUMER c2 RESET (read_from);\n"},
-             {"alter topic topic1 add consumer c1, drop consumer c2",
-              "ALTER TOPIC topic1\n\tADD CONSUMER c1,\n\tDROP CONSUMER c2;\n"},
-             {"alter topic topic1 set (supported_codecs = 'RAW'), RESET (retention_period)",
-              "ALTER TOPIC topic1\n\tSET (supported_codecs = 'RAW'),\n\tRESET (retention_period);\n"},
-
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(DropTopic) {
-        TCases cases = {
-            {"drop topic topic1",
-             "DROP TOPIC topic1;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(TopicExistsStatement) {
-        TCases cases = {
-            {"drop topic if exists topic1",
-             "DROP TOPIC IF EXISTS topic1;\n"},
-            {"create topic if not exists topic1 with (partition_count_limit = 5)",
-             "CREATE TOPIC IF NOT EXISTS topic1 WITH (\n\tpartition_count_limit = 5\n);\n"},
-             {"alter topic if exists topic1 alter consumer c1 set (important = false)",
-             "ALTER TOPIC IF EXISTS topic1\n\tALTER CONSUMER c1 SET (important = FALSE);\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(Do) {
-        TCases cases = {
-            {"do $a(1,2,3)",
-             "DO $a(1, 2, 3);\n"},
-            {"do begin values(1); end do;",
-             "DO BEGIN\n\tVALUES\n\t\t(1);\nEND DO;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(DefineActionOrSubquery) {
-        TCases cases = {
-            {"define action $a() as "
-             "define action $b() as "
-             "values(1); "
-             "end define; "
-             "define subquery $c() as "
-             "select 1; "
-             "end define; "
-             "do $b(); "
-             "process $c(); "
-             "end define",
-             "DEFINE ACTION $a() AS\n\tDEFINE ACTION $b() AS\n\t\t"
-             "VALUES\n\t\t\t(1);\n\tEND DEFINE;\n\n\t"
-             "DEFINE SUBQUERY $c() AS\n\t\tSELECT\n\t\t\t1;\n\t"
-             "END DEFINE;\n\tDO $b();\n\n\tPROCESS $c();\nEND DEFINE;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(If) {
-        TCases cases = {
-            {"evaluate if 1=1 do $a()",
-             "EVALUATE IF 1 = 1\n\tDO $a();\n"},
-            {"evaluate if 1=1 do $a() else do $b()",
-             "EVALUATE IF 1 = 1\n\tDO $a()\nELSE\n\tDO $b();\n"},
-            {"evaluate if 1=1 do begin select 1; end do",
-             "EVALUATE IF 1 = 1\n\tDO BEGIN\n\t\tSELECT\n\t\t\t1;\n\tEND DO;\n"},
-            {"evaluate if 1=1 do begin select 1; end do else do begin select 2; end do",
-             "EVALUATE IF 1 = 1\n\tDO BEGIN\n\t\tSELECT\n\t\t\t1;\n\tEND DO\n"
-             "ELSE\n\tDO BEGIN\n\t\tSELECT\n\t\t\t2;\n\tEND DO;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(For) {
-        TCases cases = {
-            {"evaluate for $x in [] do $a($x)",
-             "EVALUATE FOR $x IN []\n\tDO $a($x);\n"},
-            {"evaluate for $x in [] do $a($x) else do $b()",
-             "EVALUATE FOR $x IN []\n\tDO $a($x)\nELSE\n\tDO $b();\n"},
-            {"evaluate for $x in [] do begin select $x; end do",
-             "EVALUATE FOR $x IN []\n\tDO BEGIN\n\t\tSELECT\n\t\t\t$x;\n\tEND DO;\n"},
-            {"evaluate for $x in [] do begin select $x; end do else do begin select 2; end do",
-             "EVALUATE FOR $x IN []\n\tDO BEGIN\n\t\tSELECT\n\t\t\t$x;\n\tEND DO\nELSE\n\tDO BEGIN\n\t\tSELECT\n\t\t\t2;\n\tEND DO;\n"},
-            {"evaluate parallel for $x in [] do $a($x)",
-             "EVALUATE PARALLEL FOR $x IN []\n\tDO $a($x);\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(Update) {
-        TCases cases = {
-            {"update user on default values",
-             "UPDATE user\nON DEFAULT VALUES;\n"},
-            {"update user on values (1),(2)",
-             "UPDATE user\nON\nVALUES\n\t(1),\n\t(2);\n"},
-            {"update user on select 1 as x, 2 as y",
-             "UPDATE user\nON\nSELECT\n\t1 AS x,\n\t2 AS y;\n"},
-            {"update user on (x) values (1),(2),(3)",
-             "UPDATE user\nON (\n\tx\n)\nVALUES\n\t(1),\n\t(2),\n\t(3);\n"},
-            {"update user on (x,y) values (1,2),(2,3),(3,4)",
-             "UPDATE user\nON (\n\tx,\n\ty\n)\nVALUES\n\t(1, 2),\n\t(2, 3),\n\t(3, 4);\n"},
-            {"update user on (x) select 1",
-             "UPDATE user\nON (\n\tx\n)\nSELECT\n\t1;\n"},
-            {"update user on (x,y) select 1,2",
-             "UPDATE user\nON (\n\tx,\n\ty\n)\nSELECT\n\t1,\n\t2;\n"},
-            {"update user set x=1",
-             "UPDATE user\nSET\n\tx = 1;\n"},
-            {"update user set (x)=(1)",
-             "UPDATE user\nSET\n(\n\tx\n) = (\n\t1\n);\n"},
-            {"update user set (x,y)=(1,2)",
-             "UPDATE user\nSET\n(\n\tx,\n\ty\n) = (\n\t1,\n\t2\n);\n"},
-            {"update user set (x,y)=(select 1,2)",
-             "UPDATE user\nSET\n(\n\tx,\n\ty\n) = (\n\tSELECT\n\t\t1,\n\t\t2\n);\n"},
-            {"update user set x=1,y=2 where z=3",
-             "UPDATE user\nSET\n\tx = 1,\n\ty = 2\nWHERE z = 3;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(Delete) {
-        TCases cases = {
-            {"delete from user",
-             "DELETE FROM user;\n"},
-            {"delete from user where 1=1",
-             "DELETE FROM user\nWHERE 1 = 1;\n"},
-            {"delete from user on select 1 as x, 2 as y",
-             "DELETE FROM user\nON\nSELECT\n\t1 AS x,\n\t2 AS y;\n"},
-            {"delete from user on (x) values (1)",
-             "DELETE FROM user\nON (\n\tx\n)\nVALUES\n\t(1);\n"},
-            {"delete from user on (x,y) values (1,2), (3,4)",
-             "DELETE FROM user\nON (\n\tx,\n\ty\n)\nVALUES\n\t(1, 2),\n\t(3, 4);\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(Into) {
-        TCases cases = {
-            {"insert into user select 1 as x",
-             "INSERT INTO user\nSELECT\n\t1 AS x;\n"},
-            {"insert or abort into user select 1 as x",
-             "INSERT OR ABORT INTO user\nSELECT\n\t1 AS x;\n"},
-            {"insert or revert into user select 1 as x",
-             "INSERT OR REVERT INTO user\nSELECT\n\t1 AS x;\n"},
-            {"insert or ignore into user select 1 as x",
-             "INSERT OR IGNORE INTO user\nSELECT\n\t1 AS x;\n"},
-            {"upsert into user select 1 as x",
-             "UPSERT INTO user\nSELECT\n\t1 AS x;\n"},
-            {"replace into user select 1 as x",
-             "REPLACE INTO user\nSELECT\n\t1 AS x;\n"},
-            {"insert into user(x) values (1)",
-             "INSERT INTO user (\n\tx\n)\nVALUES\n\t(1);\n"},
-            {"insert into user(x,y) values (1,2)",
-             "INSERT INTO user (\n\tx,\n\ty\n)\nVALUES\n\t(1, 2);\n"},
-            {"insert into plato.user select 1 as x",
-             "INSERT INTO plato.user\nSELECT\n\t1 AS x;\n"},
-            {"insert into @user select 1 as x",
-             "INSERT INTO @user\nSELECT\n\t1 AS x;\n"},
-            {"insert into $user select 1 as x",
-             "INSERT INTO $user\nSELECT\n\t1 AS x;\n"},
-            {"insert into @$user select 1 as x",
-             "INSERT INTO @$user\nSELECT\n\t1 AS x;\n"},
-            {"upsert into user erase by (x,y) values (1)",
-             "UPSERT INTO user\n\tERASE BY (\n\t\tx,\n\t\ty\n\t)\nVALUES\n\t(1);\n"},
-            {"insert into user with truncate select 1 as x",
-             "INSERT INTO user\n\tWITH truncate\nSELECT\n\t1 AS x;\n"},
-            {"insert into user with (truncate,inferscheme='1') select 1 as x",
-             "INSERT INTO user\n\tWITH (truncate, inferscheme = '1')\nSELECT\n\t1 AS x;\n"},
-            {"insert into user with schema Struct<user:int32> select 1 as user",
-             "INSERT INTO user\n\tWITH SCHEMA Struct<user: int32>\nSELECT\n\t1 AS user;\n"},
-            {"insert into user with schema (int32 as user) select 1 as user",
-             "INSERT INTO user\n\tWITH SCHEMA (int32 AS user)\nSELECT\n\t1 AS user;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(Process) {
-        TCases cases = {
-            {"process user",
-             "PROCESS user;\n"},
-            {"process user using $f() as user",
-             "PROCESS user\nUSING $f() AS user;\n"},
-            {"process user,user using $f()",
-             "PROCESS user, user\nUSING $f();\n"},
-            {"process user using $f() where 1=1 having 1=1 assume order by user",
-             "PROCESS user\nUSING $f()\nWHERE 1 = 1\nHAVING 1 = 1\nASSUME ORDER BY\n\tuser;\n"},
-            {"process user using $f() union all process user using $f()",
-             "PROCESS user\nUSING $f()\nUNION ALL\nPROCESS user\nUSING $f();\n"},
-            {"process user using $f() with foo=bar",
-             "PROCESS user\nUSING $f()\nWITH foo = bar;\n"},
-            {"discard process user using $f()",
-             "DISCARD PROCESS user\nUSING $f();\n"},
-            {"process user using $f() into result user",
-             "PROCESS user\nUSING $f()\nINTO RESULT user;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(Reduce) {
-        TCases cases = {
-            {"reduce user on user using $f()",
-             "REDUCE user\nON\n\tuser\nUSING $f();\n"},
-            {"reduce user on user, using $f()",
-             "REDUCE user\nON\n\tuser,\nUSING $f();\n"},
-            {"discard reduce user on user using $f();",
-             "DISCARD REDUCE user\nON\n\tuser\nUSING $f();\n"},
-            {"reduce user on user using $f() into result user",
-             "REDUCE user\nON\n\tuser\nUSING $f()\nINTO RESULT user;\n"},
-            {"reduce user on user using all $f()",
-             "REDUCE user\nON\n\tuser\nUSING ALL $f();\n"},
-            {"reduce user on user using $f() as user",
-             "REDUCE user\nON\n\tuser\nUSING $f() AS user;\n"},
-            {"reduce user,user on user using $f()",
-             "REDUCE user, user\nON\n\tuser\nUSING $f();\n"},
-            {"reduce user on user,user using $f()",
-             "REDUCE user\nON\n\tuser,\n\tuser\nUSING $f();\n"},
-            {"reduce user on user using $f() where 1=1 having 1=1 assume order by user",
-             "REDUCE user\nON\n\tuser\nUSING $f()\nWHERE 1 = 1\nHAVING 1 = 1\nASSUME ORDER BY\n\tuser;\n"},
-            {"reduce user presort user,user on user using $f();",
-             "REDUCE user\nPRESORT\n\tuser,\n\tuser\nON\n\tuser\nUSING $f();\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(Select) {
-        TCases cases = {
-            {"select 1",
-             "SELECT\n\t1;\n"},
-            {"select 1,",
-             "SELECT\n\t1,;\n"},
-            {"select 1 as x",
-             "SELECT\n\t1 AS x;\n"},
-            {"select *",
-             "SELECT\n\t*;\n"},
-            {"select a.*",
-             "SELECT\n\ta.*;\n"},
-            {"select * without a",
-             "SELECT\n\t*\n\tWITHOUT\n\t\ta;\n"},
-            {"select * without a,b",
-             "SELECT\n\t*\n\tWITHOUT\n\t\ta,\n\t\tb;\n"},
-            {"select * without a,",
-             "SELECT\n\t*\n\tWITHOUT\n\t\ta,;\n"},
-            {"select 1 from user",
-             "SELECT\n\t1\nFROM user;\n"},
-            {"select 1 from plato.user",
-             "SELECT\n\t1\nFROM plato.user;\n"},
-            {"select 1 from $user",
-             "SELECT\n\t1\nFROM $user;\n"},
-            {"select 1 from @user",
-             "SELECT\n\t1\nFROM @user;\n"},
-            {"select 1 from @$user",
-             "SELECT\n\t1\nFROM @$user;\n"},
-            {"select 1 from user view user",
-             "SELECT\n\t1\nFROM user\n\tVIEW user;\n"},
-            {"select 1 from user as user",
-             "SELECT\n\t1\nFROM user\n\tAS user;\n"},
-            {"select 1 from user as user(user)",
-             "SELECT\n\t1\nFROM user\n\tAS user (\n\t\tuser\n\t);\n"},
-            {"select 1 from user as user(user, user)",
-             "SELECT\n\t1\nFROM user\n\tAS user (\n\t\tuser,\n\t\tuser\n\t);\n"},
-            {"select 1 from user with user=user",
-             "SELECT\n\t1\nFROM user\n\tWITH user = user;\n"},
-            {"select 1 from user with (user=user, user=user)",
-             "SELECT\n\t1\nFROM user\n\tWITH (user = user, user = user);\n"},
-            {"select 1 from user sample 0.1",
-             "SELECT\n\t1\nFROM user\n\tSAMPLE 0.1;\n"},
-            {"select 1 from user tablesample system(0.1)",
-             "SELECT\n\t1\nFROM user\n\tTABLESAMPLE SYSTEM (0.1);\n"},
-            {"select 1 from user tablesample bernoulli(0.1) repeatable(10)",
-             "SELECT\n\t1\nFROM user\n\tTABLESAMPLE BERNOULLI (0.1) REPEATABLE (10);\n"},
-            {"select 1 from user flatten columns",
-             "SELECT\n\t1\nFROM user\n\tFLATTEN COLUMNS;\n"},
-            {"select 1 from user flatten list by user",
-             "SELECT\n\t1\nFROM user\n\tFLATTEN LIST BY\n\t\tuser;\n"},
-            {"select 1 from user flatten list by (user,user)",
-             "SELECT\n\t1\nFROM user\n\tFLATTEN LIST BY (\n\t\tuser,\n\t\tuser\n\t);\n"},
-            {"select 1 from $user(1,2)",
-             "SELECT\n\t1\nFROM $user(1, 2);\n"},
-            {"select 1 from $user(1,2) view user",
-             "SELECT\n\t1\nFROM $user(1, 2)\n\tVIEW user;\n"},
-            {"select 1 from range('a','b')",
-             "SELECT\n\t1\nFROM range('a', 'b');\n"},
-            {"from user select 1",
-             "FROM user\nSELECT\n\t1;\n"},
-            {"select * from user as a join user as b on a.x=b.y",
-             "SELECT\n\t*\nFROM user\n\tAS a\nJOIN user\n\tAS b\nON a.x = b.y;\n"},
-            {"select * from user as a join user as b using(x)",
-             "SELECT\n\t*\nFROM user\n\tAS a\nJOIN user\n\tAS b\nUSING (x);\n"},
-            {"select * from any user as a full join user as b on a.x=b.y",
-             "SELECT\n\t*\nFROM ANY user\n\tAS a\nFULL JOIN user\n\tAS b\nON a.x = b.y;\n"},
-            {"select * from user as a left join any user as b on a.x=b.y",
-             "SELECT\n\t*\nFROM user\n\tAS a\nLEFT JOIN ANY user\n\tAS b\nON a.x = b.y;\n"},
-            {"select * from any user as a right join any user as b on a.x=b.y",
-             "SELECT\n\t*\nFROM ANY user\n\tAS a\nRIGHT JOIN ANY user\n\tAS b\nON a.x = b.y;\n"},
-            {"select * from user as a cross join user as b",
-             "SELECT\n\t*\nFROM user\n\tAS a\nCROSS JOIN user\n\tAS b;\n"},
-            {"select 1 from user where key = 1",
-             "SELECT\n\t1\nFROM user\nWHERE key = 1;\n"},
-            {"select 1 from user having count(*) = 1",
-             "SELECT\n\t1\nFROM user\nHAVING count(*) = 1;\n"},
-            {"select 1 from user group by key",
-             "SELECT\n\t1\nFROM user\nGROUP BY\n\tkey;\n"},
-            {"select 1 from user group compact by key, value as v",
-             "SELECT\n\t1\nFROM user\nGROUP COMPACT BY\n\tkey,\n\tvalue AS v;\n"},
-            {"select 1 from user group by key with combine",
-             "SELECT\n\t1\nFROM user\nGROUP BY\n\tkey\n\tWITH combine;\n"},
-            {"select 1 from user order by key asc",
-             "SELECT\n\t1\nFROM user\nORDER BY\n\tkey ASC;\n"},
-            {"select 1 from user order by key, value desc",
-             "SELECT\n\t1\nFROM user\nORDER BY\n\tkey,\n\tvalue DESC;\n"},
-            {"select 1 from user assume order by key",
-             "SELECT\n\t1\nFROM user\nASSUME ORDER BY\n\tkey;\n"},
-            {"select 1 from user window w1 as (), w2 as ()",
-             "SELECT\n\t1\nFROM user\nWINDOW\n\tw1 AS (),\n\tw2 AS ();\n"},
-            {"select 1 from user window w1 as (user)",
-             "SELECT\n\t1\nFROM user\nWINDOW\n\tw1 AS (\n\t\tuser\n\t);\n"},
-            {"select 1 from user window w1 as (partition by user)",
-             "SELECT\n\t1\nFROM user\nWINDOW\n\tw1 AS (\n\t\tPARTITION BY\n\t\t\tuser\n\t);\n"},
-            {"select 1 from user window w1 as (partition by user, user)",
-             "SELECT\n\t1\nFROM user\nWINDOW\n\tw1 AS (\n\t\tPARTITION BY\n\t\t\tuser,\n\t\t\tuser\n\t);\n"},
-            {"select 1 from user window w1 as (order by user asc)",
-             "SELECT\n\t1\nFROM user\nWINDOW\n\tw1 AS (\n\t\tORDER BY\n\t\t\tuser ASC\n\t);\n"},
-            {"select 1 from user window w1 as (order by user, user desc)",
-             "SELECT\n\t1\nFROM user\nWINDOW\n\tw1 AS (\n\t\tORDER BY\n\t\t\tuser,\n\t\t\tuser DESC\n\t);\n"},
-            {"select 1 from user window w1 as (rows between 1 preceding and 1 following)",
-             "SELECT\n\t1\nFROM user\nWINDOW\n\tw1 AS (\n\t\tROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING\n\t);\n"},
-            {"select 1 limit 10",
-             "SELECT\n\t1\nLIMIT 10;\n"},
-            {"select 1 limit 10 offset 5",
-             "SELECT\n\t1\nLIMIT 10 OFFSET 5;\n"},
-            { "select 1 union all select 2",
-             "SELECT\n\t1\nUNION ALL\nSELECT\n\t2;\n" },
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(CompositeTypesAndQuestions) {
-        TCases cases = {
-            {"declare $_x AS list<int32>??;declare $_y AS int32 ? ? ;select 1<>2, 1??2,"
-             "formattype(list<int32>), formattype(resource<user>),formattype(tuple<>), formattype(tuple<  >), formattype(int32 ? ? )",
-             "DECLARE $_x AS list<int32>??;\nDECLARE $_y AS int32??;\n\nSELECT\n\t1 <> 2,\n\t1 ?? 2,\n\tformattype(list<int32>),"
-            "\n\tformattype(resource<user>),\n\tformattype(tuple<>),\n\tformattype(tuple< >),\n\tformattype(int32??" ");\n"
-            },
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(Lambda) {
-        TCases cases = {
-            {"$f=($a,$b)->{$x=$a+$b;return $a*$x};$g=($a,$b?)->($a+$b??0);select $f(10,4),$g(1,2);",
-             "$f = ($a, $b) -> {\n\t$x = $a + $b;\n\tRETURN $a * $x\n};\n"
-             "$g = ($a, $b?) -> ($a + $b ?? 0);\n\n"
-            "SELECT\n\t$f(10, 4),\n\t$g(1, 2);\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(NestedSelect) {
-        TCases cases = {
-            {"$x=select 1",
-             "$x =\n\tSELECT\n\t\t1;\n"},
-            {"$x=(select 1)",
-             "$x = (\n\tSELECT\n\t\t1\n);\n"},
-            {"select 1 in (select 1)",
-             "SELECT\n\t1 IN (\n\t\tSELECT\n\t\t\t1\n\t);\n"},
-            {"select 1 in ((select 1))",
-             "SELECT\n\t1 IN (\n\t\t(\n\t\t\tSELECT\n\t\t\t\t1\n\t\t)\n\t);\n"},
-            {"select 1 in (\nselect 1)",
-             "SELECT\n\t1 IN (\n\t\tSELECT\n\t\t\t1\n\t);\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(Cast) {
-        TCases cases = {
-            {"select cast(1 as string)","SELECT\n\tCAST(1 AS string);\n"},
-            {"select bitcast(1 as int32)","SELECT\n\tBITCAST(1 AS int32);\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(StructLiteral) {
-        TCases cases = {
-            {"select <||>","SELECT\n\t<||>;\n"},
-            {"select <|a:1|>","SELECT\n\t<|a: 1|>;\n"},
-            {"select <|a:1,b:2|>","SELECT\n\t<|a: 1, b: 2|>;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(TableHints) {
-        TCases cases = {
-            {"select * from plato.T with schema(foo int32, bar list<string>) where key is not null",
-             "SELECT\n\t*\nFROM plato.T\n\tWITH SCHEMA (foo int32, bar list<string>)\nWHERE key IS NOT NULL;\n"},
-            {"select * from plato.T with schema struct<foo:integer, Bar:list<string?>> where key<0",
-             "SELECT\n\t*\nFROM plato.T\n\tWITH SCHEMA struct<foo: integer, Bar: list<string?>>\nWHERE key < 0;\n"},
-            {"select * from plato.T with (foo=bar, x=$y, a=(a, b, c), u='aaa', schema (foo int32, bar list<string>))",
-             "SELECT\n\t*\nFROM plato.T\n\tWITH (foo = bar, x = $y, a = (a, b, c), u = 'aaa', SCHEMA (foo int32, bar list<string>));\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(BoolAsVariableName) {
-        TCases cases = {
-            {"$ False = True; select $ False;",
-             "$False = TRUE;\n\nSELECT\n\t$False;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(WithSchemaEquals) {
-        TCases cases = {
-            {"select * from plato.T with (format= csv_with_names, schema=(year int32 Null, month String, day String not   null, a Utf8, b Uint16));",
-             "SELECT\n\t*\nFROM plato.T\n\tWITH (format = csv_with_names, SCHEMA = (year int32 NULL, month String, day String NOT NULL, a Utf8, b Uint16));\n"},
-             };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(SquareBrackets) {
-        TCases cases = {
-            {"select a[0]",
-             "SELECT\n\ta[0];\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(MultiLineList) {
-        TCases cases = {
-            {"select [\n]",
-             "SELECT\n\t[\n\t];\n"},
-            {"select [1\n]",
-             "SELECT\n\t[\n\t\t1\n\t];\n"},
-            {"select [\n1]",
-             "SELECT\n\t[\n\t\t1\n\t];\n"},
-            {"select [1,\n]",
-             "SELECT\n\t[\n\t\t1,\n\t];\n"},
-            {"select [1\n,]",
-             "SELECT\n\t[\n\t\t1,\n\t];\n"},
-            {"select [\n1,]",
-             "SELECT\n\t[\n\t\t1,\n\t];\n"},
-            {"select [1,2,\n3,4]",
-             "SELECT\n\t[\n\t\t1, 2,\n\t\t3, 4\n\t];\n"},
-            {"select [1,2,\n3,4,]",
-             "SELECT\n\t[\n\t\t1, 2,\n\t\t3, 4,\n\t];\n"},
-            {"select [1,2\n,3,\n4\n,5]",
-             "SELECT\n\t[\n\t\t1, 2,\n\t\t3,\n\t\t4,\n\t\t5\n\t];\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(MultiLineTuple) {
-        TCases cases = {
-            {"select (\n)",
-             "SELECT\n\t(\n\t);\n"},
-            {"select (1,\n)",
-             "SELECT\n\t(\n\t\t1,\n\t);\n"},
-            {"select (1\n,)",
-             "SELECT\n\t(\n\t\t1,\n\t);\n"},
-            {"select (\n1,)",
-             "SELECT\n\t(\n\t\t1,\n\t);\n"},
-            {"select (1,2,\n3,4)",
-             "SELECT\n\t(\n\t\t1, 2,\n\t\t3, 4\n\t);\n"},
-            {"select (1,2,\n3,4,)",
-             "SELECT\n\t(\n\t\t1, 2,\n\t\t3, 4,\n\t);\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(MultiLineSet) {
-        TCases cases = {
-            {"select {\n}",
-             "SELECT\n\t{\n\t};\n"},
-            {"select {1\n}",
-             "SELECT\n\t{\n\t\t1\n\t};\n"},
-            {"select {\n1}",
-             "SELECT\n\t{\n\t\t1\n\t};\n"},
-            {"select {1,\n}",
-             "SELECT\n\t{\n\t\t1,\n\t};\n"},
-            {"select {1\n,}",
-             "SELECT\n\t{\n\t\t1,\n\t};\n"},
-            {"select {\n1,}",
-             "SELECT\n\t{\n\t\t1,\n\t};\n"},
-            {"select {1,2,\n3,4}",
-             "SELECT\n\t{\n\t\t1, 2,\n\t\t3, 4\n\t};\n"},
-            {"select {1,2,\n3,4,}",
-             "SELECT\n\t{\n\t\t1, 2,\n\t\t3, 4,\n\t};\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(MultiLineDict) {
-        TCases cases = {
-            {"select {0:1\n}",
-             "SELECT\n\t{\n\t\t0: 1\n\t};\n"},
-            {"select {\n0:1}",
-             "SELECT\n\t{\n\t\t0: 1\n\t};\n"},
-            {"select {0:1,\n}",
-             "SELECT\n\t{\n\t\t0: 1,\n\t};\n"},
-            {"select {0:1\n,}",
-             "SELECT\n\t{\n\t\t0: 1,\n\t};\n"},
-            {"select {\n0:1,}",
-             "SELECT\n\t{\n\t\t0: 1,\n\t};\n"},
-            {"select {10:1,20:2,\n30:3,40:4}",
-             "SELECT\n\t{\n\t\t10: 1, 20: 2,\n\t\t30: 3, 40: 4\n\t};\n"},
-            {"select {10:1,20:2,\n30:3,40:4,}",
-             "SELECT\n\t{\n\t\t10: 1, 20: 2,\n\t\t30: 3, 40: 4,\n\t};\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(MultiLineFuncCall) {
-        TCases cases = {
-            {"select f(\n)",
-             "SELECT\n\tf(\n\t);\n"},
-            {"select f(1\n)",
-             "SELECT\n\tf(\n\t\t1\n\t);\n"},
-            {"select f(\n1)",
-             "SELECT\n\tf(\n\t\t1\n\t);\n"},
-            {"select f(1,\n)",
-             "SELECT\n\tf(\n\t\t1,\n\t);\n"},
-            {"select f(1\n,)",
-             "SELECT\n\tf(\n\t\t1,\n\t);\n"},
-            {"select f(\n1,)",
-             "SELECT\n\tf(\n\t\t1,\n\t);\n"},
-            {"select f(1,2,\n3,4)",
-             "SELECT\n\tf(\n\t\t1, 2,\n\t\t3, 4\n\t);\n"},
-            {"select f(1,2,\n3,4,)",
-             "SELECT\n\tf(\n\t\t1, 2,\n\t\t3, 4,\n\t);\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(MultiLineStruct) {
-        TCases cases = {
-            {"select <|\n|>",
-             "SELECT\n\t<|\n\t|>;\n"},
-            {"select <|a:1\n|>",
-             "SELECT\n\t<|\n\t\ta: 1\n\t|>;\n"},
-            {"select <|\na:1|>",
-             "SELECT\n\t<|\n\t\ta: 1\n\t|>;\n"},
-            {"select <|a:1,\n|>",
-             "SELECT\n\t<|\n\t\ta: 1,\n\t|>;\n"},
-            {"select <|a:1\n,|>",
-             "SELECT\n\t<|\n\t\ta: 1,\n\t|>;\n"},
-            {"select <|\na:1,|>",
-             "SELECT\n\t<|\n\t\ta: 1,\n\t|>;\n"},
-            {"select <|a:1,b:2,\nc:3,d:4|>",
-             "SELECT\n\t<|\n\t\ta: 1, b: 2,\n\t\tc: 3, d: 4\n\t|>;\n"},
-            {"select <|a:1,b:2,\nc:3,d:4,|>",
-             "SELECT\n\t<|\n\t\ta: 1, b: 2,\n\t\tc: 3, d: 4,\n\t|>;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(MultiLineListType) {
-        TCases cases = {
-            {"select list<int32\n>",
-             "SELECT\n\tlist<\n\t\tint32\n\t>;\n"},
-            {"select list<\nint32>",
-             "SELECT\n\tlist<\n\t\tint32\n\t>;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(MultiLineOptionalType) {
-        TCases cases = {
-            {"select optional<int32\n>",
-             "SELECT\n\toptional<\n\t\tint32\n\t>;\n"},
-            {"select optional<\nint32>",
-             "SELECT\n\toptional<\n\t\tint32\n\t>;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(MultiLineStreamType) {
-        TCases cases = {
-            {"select stream<int32\n>",
-             "SELECT\n\tstream<\n\t\tint32\n\t>;\n"},
-            {"select stream<\nint32>",
-             "SELECT\n\tstream<\n\t\tint32\n\t>;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(MultiLineFlowType) {
-        TCases cases = {
-            {"select flow<int32\n>",
-             "SELECT\n\tflow<\n\t\tint32\n\t>;\n"},
-            {"select flow<\nint32>",
-             "SELECT\n\tflow<\n\t\tint32\n\t>;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(MultiLineSetType) {
-        TCases cases = {
-            {"select set<int32\n>",
-             "SELECT\n\tset<\n\t\tint32\n\t>;\n"},
-            {"select set<\nint32>",
-             "SELECT\n\tset<\n\t\tint32\n\t>;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(MultiLineTupleType) {
-        TCases cases = {
-            {"select tuple<\n>",
-             "SELECT\n\ttuple<\n\t\t \n\t>;\n"},
-            {"select tuple<int32\n>",
-             "SELECT\n\ttuple<\n\t\tint32\n\t>;\n"},
-            {"select tuple<\nint32>",
-             "SELECT\n\ttuple<\n\t\tint32\n\t>;\n"},
-            {"select tuple<int32,\n>",
-             "SELECT\n\ttuple<\n\t\tint32,\n\t>;\n"},
-            {"select tuple<int32\n,>",
-             "SELECT\n\ttuple<\n\t\tint32,\n\t>;\n"},
-            {"select tuple<\nint32,>",
-             "SELECT\n\ttuple<\n\t\tint32,\n\t>;\n"},
-            {"select tuple<\nint32,string,\ndouble,bool>",
-             "SELECT\n\ttuple<\n\t\tint32, string,\n\t\tdouble, bool\n\t>;\n"},
-            {"select tuple<\nint32,string,\ndouble,bool,>",
-             "SELECT\n\ttuple<\n\t\tint32, string,\n\t\tdouble, bool,\n\t>;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(MultiLineStructType) {
-        TCases cases = {
-            {"select struct<\n>",
-             "SELECT\n\tstruct<\n\t\t \n\t>;\n"},
-            {"select struct<a:int32\n>",
-             "SELECT\n\tstruct<\n\t\ta: int32\n\t>;\n"},
-            {"select struct<\na:int32>",
-             "SELECT\n\tstruct<\n\t\ta: int32\n\t>;\n"},
-            {"select struct<a:int32,\n>",
-             "SELECT\n\tstruct<\n\t\ta: int32,\n\t>;\n"},
-            {"select struct<a:int32\n,>",
-             "SELECT\n\tstruct<\n\t\ta: int32,\n\t>;\n"},
-            {"select struct<\na:int32,>",
-             "SELECT\n\tstruct<\n\t\ta: int32,\n\t>;\n"},
-            {"select struct<\na:int32,b:string,\nc:double,d:bool>",
-             "SELECT\n\tstruct<\n\t\ta: int32, b: string,\n\t\tc: double, d: bool\n\t>;\n"},
-            {"select struct<\na:int32,b:string,\nc:double,d:bool,>",
-             "SELECT\n\tstruct<\n\t\ta: int32, b: string,\n\t\tc: double, d: bool,\n\t>;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(MultiLineVariantOverTupleType) {
-        TCases cases = {
-            {"select variant<int32\n>",
-             "SELECT\n\tvariant<\n\t\tint32\n\t>;\n"},
-            {"select variant<\nint32>",
-             "SELECT\n\tvariant<\n\t\tint32\n\t>;\n"},
-            {"select variant<int32,\n>",
-             "SELECT\n\tvariant<\n\t\tint32,\n\t>;\n"},
-            {"select variant<int32\n,>",
-             "SELECT\n\tvariant<\n\t\tint32,\n\t>;\n"},
-            {"select variant<\nint32,>",
-             "SELECT\n\tvariant<\n\t\tint32,\n\t>;\n"},
-            {"select variant<\nint32,string,\ndouble,bool>",
-             "SELECT\n\tvariant<\n\t\tint32, string,\n\t\tdouble, bool\n\t>;\n"},
-            {"select variant<\nint32,string,\ndouble,bool,>",
-             "SELECT\n\tvariant<\n\t\tint32, string,\n\t\tdouble, bool,\n\t>;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(MultiLineVariantOverStructType) {
-        TCases cases = {
-            {"select variant<a:int32\n>",
-             "SELECT\n\tvariant<\n\t\ta: int32\n\t>;\n"},
-            {"select variant<\na:int32>",
-             "SELECT\n\tvariant<\n\t\ta: int32\n\t>;\n"},
-            {"select variant<a:int32,\n>",
-             "SELECT\n\tvariant<\n\t\ta: int32,\n\t>;\n"},
-            {"select variant<a:int32\n,>",
-             "SELECT\n\tvariant<\n\t\ta: int32,\n\t>;\n"},
-            {"select variant<\na:int32,>",
-             "SELECT\n\tvariant<\n\t\ta: int32,\n\t>;\n"},
-            {"select variant<\na:int32,b:string,\nc:double,d:bool>",
-             "SELECT\n\tvariant<\n\t\ta: int32, b: string,\n\t\tc: double, d: bool\n\t>;\n"},
-            {"select variant<\na:int32,b:string,\nc:double,d:bool,>",
-             "SELECT\n\tvariant<\n\t\ta: int32, b: string,\n\t\tc: double, d: bool,\n\t>;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(MultiLineEnum) {
-        TCases cases = {
-            {"select enum<a\n>",
-             "SELECT\n\tenum<\n\t\ta\n\t>;\n"},
-            {"select enum<\na>",
-             "SELECT\n\tenum<\n\t\ta\n\t>;\n"},
-            {"select enum<a,\n>",
-             "SELECT\n\tenum<\n\t\ta,\n\t>;\n"},
-            {"select enum<a\n,>",
-             "SELECT\n\tenum<\n\t\ta,\n\t>;\n"},
-            {"select enum<\na,>",
-             "SELECT\n\tenum<\n\t\ta,\n\t>;\n"},
-            {"select enum<\na,b,\nc,d>",
-             "SELECT\n\tenum<\n\t\ta, b,\n\t\tc, d\n\t>;\n"},
-            {"select enum<\na,b,\nc,d,>",
-             "SELECT\n\tenum<\n\t\ta, b,\n\t\tc, d,\n\t>;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(MultiLineResourceType) {
-        TCases cases = {
-            {"select resource<foo\n>",
-             "SELECT\n\tresource<\n\t\tfoo\n\t>;\n"},
-            {"select resource<\nfoo>",
-             "SELECT\n\tresource<\n\t\tfoo\n\t>;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(MultiLineTaggedType) {
-        TCases cases = {
-            {"select tagged<int32,foo\n>",
-             "SELECT\n\ttagged<\n\t\tint32, foo\n\t>;\n"},
-            {"select tagged<int32,\nfoo>",
-             "SELECT\n\ttagged<\n\t\tint32,\n\t\tfoo\n\t>;\n"},
-            {"select tagged<int32\n,foo>",
-             "SELECT\n\ttagged<\n\t\tint32,\n\t\tfoo\n\t>;\n"},
-            {"select tagged<\nint32,foo>",
-             "SELECT\n\ttagged<\n\t\tint32, foo\n\t>;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(MultiLineDictType) {
-        TCases cases = {
-            {"select dict<int32,string\n>",
-             "SELECT\n\tdict<\n\t\tint32, string\n\t>;\n"},
-            {"select dict<int32,\nstring>",
-             "SELECT\n\tdict<\n\t\tint32,\n\t\tstring\n\t>;\n"},
-            {"select dict<int32\n,string>",
-             "SELECT\n\tdict<\n\t\tint32,\n\t\tstring\n\t>;\n"},
-            {"select dict<\nint32,string>",
-             "SELECT\n\tdict<\n\t\tint32, string\n\t>;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(MultiLineCallableType) {
-        TCases cases = {
-            {"select callable<()->int32\n>",
-             "SELECT\n\tcallable<\n\t\t() -> int32\n\t>;\n"},
-            {"select callable<\n()->int32>",
-             "SELECT\n\tcallable<\n\t\t() -> int32\n\t>;\n"},
-            {"select callable<\n(int32)->int32>",
-             "SELECT\n\tcallable<\n\t\t(int32) -> int32\n\t>;\n"},
-            {"select callable<\n(int32,\ndouble)->int32>",
-             "SELECT\n\tcallable<\n\t\t(\n\t\t\tint32,\n\t\t\tdouble\n\t\t) -> int32\n\t>;\n"},
-            {"select callable<\n(int32\n,double)->int32>",
-             "SELECT\n\tcallable<\n\t\t(\n\t\t\tint32,\n\t\t\tdouble\n\t\t) -> int32\n\t>;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(UnaryOp) {
-        TCases cases = {
-            {"select -x,+x,~x,-1,-1.0,+1,+1.0,~1u",
-             "SELECT\n\t-x,\n\t+x,\n\t~x,\n\t-1,\n\t-1.0,\n\t+1,\n\t+1.0,\n\t~1u;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(MatchRecognize) {
-        TCases cases = {{R"(
-pragma FeatureR010="prototype";
-USE plato;
-SELECT
-    *
-FROM Input MATCH_RECOGNIZE(
-    PATTERN ( A )
-    DEFINE A as A
-);
-)",
-R"(PRAGMA FeatureR010 = "prototype";
-USE plato;
-
-SELECT
-    *
-FROM Input MATCH_RECOGNIZE (PATTERN (A) DEFINE A AS A);
-)"
-    }};
-    TSetup setup;
-    setup.Run(cases);
-}
-
-    Y_UNIT_TEST(CreateTableTrailingComma) {
-        TCases cases = {
-            {"CREATE TABLE tableName (Key Uint32, PRIMARY KEY (Key),);",
-             "CREATE TABLE tableName (\n\tKey Uint32,\n\tPRIMARY KEY (Key),\n);\n"},
-            {"CREATE TABLE tableName (Key Uint32,);",
-             "CREATE TABLE tableName (\n\tKey Uint32,\n);\n"},
-        };
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(Union) {
-        TCases cases = {
-            {"select 1 union all select 2 union select 3 union all select 4 union select 5",
-             "SELECT\n\t1\nUNION ALL\nSELECT\n\t2\nUNION\nSELECT\n\t3\nUNION ALL\nSELECT\n\t4\nUNION\nSELECT\n\t5;\n"},
-             };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(CommentAfterLastSelect) {
-        TCases cases = {
-            {"SELECT 1--comment\n",
-             "SELECT\n\t1--comment\n;\n"},
-            {"SELECT 1\n\n--comment\n",
-             "SELECT\n\t1--comment\n;\n"},
-            {"SELECT 1\n\n--comment",
-             "SELECT\n\t1--comment\n;\n"},
-            {"SELECT * FROM Input\n\n\n\n/* comment */\n\n\n",
-             "SELECT\n\t*\nFROM Input/* comment */;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(WindowFunctionInsideExpr) {
-        TCases cases = {
-            {"SELECT CAST(ROW_NUMBER() OVER () AS String) AS x,\nFROM Input;",
-             "SELECT\n\tCAST(ROW_NUMBER() OVER () AS String) AS x,\nFROM Input;\n"},
-            {"SELECT CAST(ROW_NUMBER() OVER (PARTITION BY key) AS String) AS x,\nFROM Input;",
-             "SELECT\n\tCAST(\n\t\tROW_NUMBER() OVER (\n\t\t\tPARTITION BY\n\t\t\t\tkey\n\t\t) AS String\n\t) AS x,\nFROM Input;\n"},
-            {"SELECT CAST(ROW_NUMBER() OVER (users) AS String) AS x,\nFROM Input;",
-            "SELECT\n\tCAST(\n\t\tROW_NUMBER() OVER (\n\t\t\tusers\n\t\t) AS String\n\t) AS x,\nFROM Input;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(ExistsExpr) {
-        TCases cases = {
-            {"SELECT EXISTS (SELECT 1);",
-             "SELECT\n\tEXISTS (\n\t\tSELECT\n\t\t\t1\n\t);\n"},
-            {"SELECT CAST(EXISTS(SELECT 1) AS Int) AS x,\nFROM Input;",
-             "SELECT\n\tCAST(\n\t\tEXISTS (\n\t\t\tSELECT\n\t\t\t\t1\n\t\t) AS Int\n\t) AS x,\nFROM Input;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(LambdaInsideExpr) {
-        TCases cases = {
-            {"SELECT ListMap(AsList(1,2),($x)->{return $x+1});",
-             "SELECT\n\tListMap(\n\t\tAsList(1, 2), ($x) -> {\n\t\t\tRETURN $x + 1\n\t\t}\n\t);\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(CaseExpr) {
-        TCases cases = {
-            {"SELECT CASE WHEN 1 == 2 THEN 3 WHEN 4 == 5 THEN 6 WHEN 7 == 8 THEN 9 ELSE 10 END;",
-             "SELECT\n\tCASE\n\t\tWHEN 1 == 2\n\t\t\tTHEN 3\n\t\tWHEN 4 == 5\n\t\t\tTHEN 6\n\t\tWHEN 7 == 8\n\t\t\tTHEN 9\n\t\tELSE 10\n\tEND;\n"},
-            {"SELECT CAST(CASE WHEN 1 == 2 THEN 3 WHEN 4 == 5 THEN 6 ELSE 10 END AS String);",
-             "SELECT\n\tCAST(\n\t\tCASE\n\t\t\tWHEN 1 == 2\n\t\t\t\tTHEN 3\n\t\t\tWHEN 4 == 5\n\t\t\t\tTHEN 6\n\t\t\tELSE 10\n\t\tEND AS String\n\t);\n"},
-            {"SELECT CASE x WHEN 1 THEN 2 WHEN 3 THEN 4 WHEN 5 THEN 6 ELSE 10 END;",
-             "SELECT\n\tCASE x\n\t\tWHEN 1\n\t\t\tTHEN 2\n\t\tWHEN 3\n\t\t\tTHEN 4\n\t\tWHEN 5\n\t\t\tTHEN 6\n\t\tELSE 10\n\tEND;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(MultiTokenOperations) {
-        TCases cases = {
-            {"$x = 1 >>| 2;",
-             "$x = 1 >>| 2;\n"},
-             {"$x = 1 >> 2;",
-             "$x = 1 >> 2;\n"},
-             {"$x = 1 ?? 2;",
-             "$x = 1 ?? 2;\n"},
-             {"$x = 1 >  /*comment*/  >  /*comment*/  | 2;",
-             "$x = 1 >/*comment*/>/*comment*/| 2;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(OperatorNewlines) {
-        TCases cases = {
-            {"$x = TRUE\nOR\nFALSE;",
-             "$x = TRUE\n\tOR\n\tFALSE;\n"},
-            {"$x = TRUE OR\nFALSE;",
-             "$x = TRUE OR\n\tFALSE;\n"},
-            {"$x = TRUE\nOR FALSE;",
-             "$x = TRUE OR\n\tFALSE;\n"},
-            {"$x = 1\n+2\n*3;",
-             "$x = 1 +\n\t2 *\n\t\t3;\n"},
-            {"$x = 1\n+\n2\n*3\n*5\n+\n4;",
-             "$x = 1\n\t+\n\t2 *\n\t\t3 *\n\t\t5\n\t+\n\t4;\n"},
-            {"$x = 1\n+2+3+4\n+5+6+7+\n\n8+9+10;",
-             "$x = 1 +\n\t2 + 3 + 4 +\n\t5 + 6 + 7 +\n\t8 + 9 + 10;\n"},
-            {"$x = TRUE\nAND\nTRUE OR\nFALSE\nAND TRUE\nOR FALSE\nAND TRUE\nOR FALSE;",
-             "$x = TRUE\n\tAND\n\tTRUE OR\n\tFALSE AND\n\t\tTRUE OR\n\tFALSE AND\n\t\tTRUE OR\n\tFALSE;\n"},
-            {"$x = 1 -- comment\n+ 2;",
-             "$x = 1-- comment\n\t+\n\t2;\n"},
-             {"$x = 1 -- comment\n+ -- comment\n2;",
-             "$x = 1-- comment\n\t+-- comment\n\t2;\n"},
-             {"$x = 1 + -- comment\n2;",
-             "$x = 1 +-- comment\n\t2;\n"},
-             {"$x = 1\n>\n>\n|\n2;",
-             "$x = 1\n\t>>|\n\t2;\n"},
-             {"$x = 1\n?? 2 ??\n3\n??\n4 +\n5\n*\n6 +\n7 ??\n8;",
-             "$x = 1 ??\n\t2 ??\n\t3\n\t??\n\t4 +\n\t\t5\n\t\t\t*\n\t\t\t6 +\n\t\t7 ??\n\t8;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(ObfuscateSelect) {
-        TCases cases = {
-            {"select 1;",
-             "SELECT\n\t0;\n"},
-            {"select true;",
-             "SELECT\n\tFALSE;\n"},
-            {"select 'foo';",
-             "SELECT\n\t'str';\n"},
-            {"select 3.0;",
-             "SELECT\n\t0.0;\n"},
-            {"select col;",
-             "SELECT\n\tid;\n"},
-            {"select * from tab;",
-             "SELECT\n\t*\nFROM id;\n"},
-            {"select cast(col as int32);",
-             "SELECT\n\tCAST(id AS int32);\n"},
-            {"select func(col);",
-             "SELECT\n\tfunc(id);\n"},
-            {"select mod::func(col);",
-             "SELECT\n\tmod::func(id);\n"},
-            {"declare $a as int32;",
-             "DECLARE $id AS int32;\n"},
-            {"select * from `logs/of/bob` where pwd='foo';",
-             "SELECT\n\t*\nFROM id\nWHERE id = 'str';\n"},
-            {"select $f();",
-             "SELECT\n\t$id();\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases, NSQLFormat::EFormatMode::Obfuscate);
-    }
-
-    Y_UNIT_TEST(ObfuscatePragma) {
-        TCases cases = {
-            {"pragma a=1",
-             "PRAGMA id = 0;\n"},
-            {"pragma a='foo';",
-             "PRAGMA id = 'str';\n"},
-            {"pragma a=true;",
-             "PRAGMA id = FALSE;\n"},
-            {"pragma a=$foo;",
-             "PRAGMA id = $id;\n"},
-            {"pragma a=foo;",
-             "PRAGMA id = id;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases, NSQLFormat::EFormatMode::Obfuscate);
-    }
-
-    Y_UNIT_TEST(CreateView) {
-        TCases cases = {
-            {"creAte vIEw TheView wiTh (security_invoker = trUE) As SELect 1",
-             "CREATE VIEW TheView WITH (security_invoker = TRUE) AS\nSELECT\n\t1;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(DropView) {
-        TCases cases = {
-            {"dRop viEW theVIEW",
-             "DROP VIEW theVIEW;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(ResourcePoolOperations) {
-        TCases cases = {
-            {"creAte reSourCe poOl naMe With (a = \"b\")",
-             "CREATE RESOURCE POOL naMe WITH (a = \"b\");\n"},
-             {"create resource pool eds with (a=\"a\",b=\"b\",c = true)",
-             "CREATE RESOURCE POOL eds WITH (\n\ta = \"a\",\n\tb = \"b\",\n\tc = TRUE\n);\n"},
-             {"alTer reSOurcE poOl naMe resEt (b, c), seT (x=y, z=false)",
-             "ALTER RESOURCE POOL naMe\n\tRESET (b, c),\n\tSET (x = y, z = FALSE);\n"},
-             {"alter resource pool eds reset (a), set (x=y)",
-             "ALTER RESOURCE POOL eds\n\tRESET (a),\n\tSET (x = y);\n"},
-            {"dRop reSourCe poOl naMe",
-             "DROP RESOURCE POOL naMe;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(BackupCollectionOperations) {
-        TCases cases = {
-            {"creAte  BackuP colLection `-naMe` wIth (a = \"b\")",
-             "CREATE BACKUP COLLECTION `-naMe` WITH (a = \"b\");\n"},
-             {"alTer bACKuP coLLECTION naMe resEt (b, c), seT (x=y, z=false)",
-             "ALTER BACKUP COLLECTION naMe\n\tRESET (b, c),\n\tSET (x = y, z = FALSE);\n"},
-            {"DROP backup collectiOn       `/some/path`",
-             "DROP BACKUP COLLECTION `/some/path`;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(Analyze) {
-        TCases cases = {
-            {"analyze table (col1, col2, col3)",
-             "ANALYZE table (col1, col2, col3);\n"},
-             {"analyze table",
-             "ANALYZE table;\n"}
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
-
-    Y_UNIT_TEST(ResourcePoolClassifierOperations) {
-        TCases cases = {
-            {"creAte reSourCe poOl ClaSsiFIer naMe With (a = \"b\")",
-             "CREATE RESOURCE POOL CLASSIFIER naMe WITH (a = \"b\");\n"},
-             {"create resource pool classifier eds with (a=\"a\",b=\"b\",c = true)",
-             "CREATE RESOURCE POOL CLASSIFIER eds WITH (\n\ta = \"a\",\n\tb = \"b\",\n\tc = TRUE\n);\n"},
-             {"alTer reSOurcE poOl ClaSsiFIer naMe resEt (b, c), seT (x=y, z=false)",
-             "ALTER RESOURCE POOL CLASSIFIER naMe\n\tRESET (b, c),\n\tSET (x = y, z = FALSE);\n"},
-             {"alter resource pool classifier eds reset (a), set (x=y)",
-             "ALTER RESOURCE POOL CLASSIFIER eds\n\tRESET (a),\n\tSET (x = y);\n"},
-            {"dRop reSourCe poOl ClaSsiFIer naMe",
-             "DROP RESOURCE POOL CLASSIFIER naMe;\n"},
-        };
-
-        TSetup setup;
-        setup.Run(cases);
-    }
+    #include "sql_format_ut.h"
 }
diff --git a/ydb/library/yql/sql/v1/format/sql_format_ut.h b/ydb/library/yql/sql/v1/format/sql_format_ut.h
new file mode 100644
index 000000000000..2390f1ab51c8
--- /dev/null
+++ b/ydb/library/yql/sql/v1/format/sql_format_ut.h
@@ -0,0 +1,1618 @@
+Y_UNIT_TEST(Pragma) {
+    TCases cases = {
+        {"pragma user = user;","PRAGMA user = user;\n"},
+        {"pragma user = default;","PRAGMA user = default;\n"},
+        {"pragma user.user = user;","PRAGMA user.user = user;\n"},
+        {"pragma user.user(user);","PRAGMA user.user(user);\n"},
+        {"pragma user.user(user, user);","PRAGMA user.user(user, user);\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(DotAfterDigits) {
+    TCases cases = {
+        {"select a.1 .b from plato.foo;","SELECT\n\ta.1 .b\nFROM plato.foo;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(GrantPermissions) {
+    TCases cases {
+        {"use plato;grant connect, modify tables, list on `/Root` to user;", "USE plato;\n\nGRANT CONNECT, MODIFY TABLES, LIST ON `/Root` TO user;\n"},
+        {"use plato;grant select , select tables, select attributes on `/Root` to user;", "USE plato;\n\nGRANT SELECT, SELECT TABLES, SELECT ATTRIBUTES ON `/Root` TO user;\n"},
+        {"use plato;grant insert, modify attributes on `/Root` to user;", "USE plato;\n\nGRANT INSERT, MODIFY ATTRIBUTES ON `/Root` TO user;\n"},
+        {"use plato;grant use legacy, use on `/Root` to user1, user2;", "USE plato;\n\nGRANT USE LEGACY, USE ON `/Root` TO user1, user2;\n"},
+        {"use plato;grant manage, full legacy, full, create on `/Root` to user;", "USE plato;\n\nGRANT MANAGE, FULL LEGACY, FULL, CREATE ON `/Root` TO user;\n"},
+        {"use plato;grant drop, grant, select row, update row on `/Root` to user;", "USE plato;\n\nGRANT DROP, GRANT, SELECT ROW, UPDATE ROW ON `/Root` TO user;\n"},
+        {"use plato;grant erase row, create directory on `/Root` to user;", "USE plato;\n\nGRANT ERASE ROW, CREATE DIRECTORY ON `/Root` TO user;\n"},
+        {"use plato;grant create table, create queue, remove schema on `/Root` to user;", "USE plato;\n\nGRANT CREATE TABLE, CREATE QUEUE, REMOVE SCHEMA ON `/Root` TO user;\n"},
+        {"use plato;grant describe schema, alter schema on `/Root` to user;", "USE plato;\n\nGRANT DESCRIBE SCHEMA, ALTER SCHEMA ON `/Root` TO user;\n"},
+        {"use plato;grant select, on `/Root` to user, with grant option;", "USE plato;\n\nGRANT SELECT, ON `/Root` TO user, WITH GRANT OPTION;\n"},
+        {"use plato;grant all privileges on `/Root` to user;", "USE plato;\n\nGRANT ALL PRIVILEGES ON `/Root` TO user;\n"},
+        {"use plato;grant list on `/Root/db1`, `/Root/db2` to user;", "USE plato;\n\nGRANT LIST ON `/Root/db1`, `/Root/db2` TO user;\n"}
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(RevokePermissions) {
+    TCases cases {
+        {"use plato;revoke connect, modify tables, list on `/Root` from user;", "USE plato;\n\nREVOKE CONNECT, MODIFY TABLES, LIST ON `/Root` FROM user;\n"},
+        {"use plato;revoke select , select tables, select attributes on `/Root` from user;", "USE plato;\n\nREVOKE SELECT, SELECT TABLES, SELECT ATTRIBUTES ON `/Root` FROM user;\n"},
+        {"use plato;revoke insert, modify attributes on `/Root` from user;", "USE plato;\n\nREVOKE INSERT, MODIFY ATTRIBUTES ON `/Root` FROM user;\n"},
+        {"use plato;revoke use legacy, use on `/Root` from user1, user2;", "USE plato;\n\nREVOKE USE LEGACY, USE ON `/Root` FROM user1, user2;\n"},
+        {"use plato;revoke manage, full legacy, full, create on `/Root` from user;", "USE plato;\n\nREVOKE MANAGE, FULL LEGACY, FULL, CREATE ON `/Root` FROM user;\n"},
+        {"use plato;revoke drop, grant, select row, update row on `/Root` from user;", "USE plato;\n\nREVOKE DROP, GRANT, SELECT ROW, UPDATE ROW ON `/Root` FROM user;\n"},
+        {"use plato;revoke erase row, create directory on `/Root` from user;", "USE plato;\n\nREVOKE ERASE ROW, CREATE DIRECTORY ON `/Root` FROM user;\n"},
+        {"use plato;revoke create table, create queue, remove schema on `/Root` from user;", "USE plato;\n\nREVOKE CREATE TABLE, CREATE QUEUE, REMOVE SCHEMA ON `/Root` FROM user;\n"},
+        {"use plato;revoke describe schema, alter schema on `/Root` from user;", "USE plato;\n\nREVOKE DESCRIBE SCHEMA, ALTER SCHEMA ON `/Root` FROM user;\n"},
+        {"use plato;revoke grant option for insert, on `/Root` from user;", "USE plato;\n\nREVOKE GRANT OPTION FOR INSERT, ON `/Root` FROM user;\n"},
+        {"use plato;revoke all privileges on `/Root` from user;", "USE plato;\n\nREVOKE ALL PRIVILEGES ON `/Root` FROM user;\n"},
+        {"use plato;revoke list on `/Root/db1`, `/Root/db2` from user;", "USE plato;\n\nREVOKE LIST ON `/Root/db1`, `/Root/db2` FROM user;\n"}
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(DropRole) {
+    TCases cases = {
+        {"use plato;drop user user,user,user;","USE plato;\n\nDROP USER user, user, user;\n"},
+        {"use plato;drop group if exists user;","USE plato;\n\nDROP GROUP IF EXISTS user;\n"},
+        {"use plato;drop group user,;","USE plato;\n\nDROP GROUP user,;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(CreateUser) {
+    TCases cases = {
+        {"use plato;create user user;","USE plato;\n\nCREATE USER user;\n"},
+        {"use plato;create user user encrypted password 'foo';","USE plato;\n\nCREATE USER user ENCRYPTED PASSWORD 'foo';\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(CreateGroup) {
+    TCases cases = {
+        {"use plato;create group user;","USE plato;\n\nCREATE GROUP user;\n"},
+        {"use plato;create group user with user user;","USE plato;\n\nCREATE GROUP user WITH USER user;\n"},
+        {"use plato;create group user with user user, user,;","USE plato;\n\nCREATE GROUP user WITH USER user, user,;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(AlterUser) {
+    TCases cases = {
+        {"use plato;alter user user rename to user;","USE plato;\n\nALTER USER user RENAME TO user;\n"},
+        {"use plato;alter user user encrypted password 'foo';","USE plato;\n\nALTER USER user ENCRYPTED PASSWORD 'foo';\n"},
+        {"use plato;alter user user with encrypted password 'foo';","USE plato;\n\nALTER USER user WITH ENCRYPTED PASSWORD 'foo';\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(AlterGroup) {
+    TCases cases = {
+        {"use plato;alter group user add user user;","USE plato;\n\nALTER GROUP user ADD USER user;\n"},
+        {"use plato;alter group user drop user user;","USE plato;\n\nALTER GROUP user DROP USER user;\n"},
+        {"use plato;alter group user add user user, user,;","USE plato;\n\nALTER GROUP user ADD USER user, user,;\n"},
+        {"use plato;alter group user rename to user;","USE plato;\n\nALTER GROUP user RENAME TO user;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(Use) {
+    TCases cases = {
+        {"use user;","USE user;\n"},
+        {"use user:user;","USE user: user;\n"},
+        {"use user:*;","USE user: *;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(Commit) {
+    TCases cases = {
+        {"commit;","COMMIT;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(Rollback) {
+    TCases cases = {
+        {"rollback;","ROLLBACK;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(Export) {
+    TCases cases = {
+        {"export $foo;","EXPORT $foo;\n"},
+        {"export $foo, $bar;","EXPORT $foo, $bar;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(Import) {
+    TCases cases = {
+        {"import user symbols $foo;","IMPORT user SYMBOLS $foo;\n"},
+        {"import user symbols $foo,$bar;","IMPORT user SYMBOLS $foo, $bar;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(Values) {
+    TCases cases = {
+        {"values (1);","VALUES\n\t(1);\n"},
+        {"values (1,2),(3,4);","VALUES\n\t(1, 2),\n\t(3, 4);\n"},
+        {"values ('a\nb');","VALUES\n\t('a\nb');\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(Declare) {
+    TCases cases = {
+        {"declare $foo as int32;","DECLARE $foo AS int32;\n"},
+        {"declare $foo as bool ?","DECLARE $foo AS bool?;\n"},
+        {"declare $foo as bool ? ?","DECLARE $foo AS bool??;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(NamedNode) {
+    TCases cases = {
+        {"$x=1","$x = 1;\n"},
+        {"$x,$y=(2,3)","$x, $y = (2, 3);\n"},
+        {"$a = select 1 union all select 2","$a =\n\tSELECT\n\t\t1\n\tUNION ALL\n\tSELECT\n\t\t2;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(DropTable) {
+    TCases cases = {
+        {"drop table user","DROP TABLE user;\n"},
+        {"drop table if exists user","DROP TABLE IF EXISTS user;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(CreateTable) {
+    TCases cases = {
+        {"create table user(user int32)","CREATE TABLE user (\n\tuser int32\n);\n"},
+        {"create table user(user int32,user bool ?)","CREATE TABLE user (\n\tuser int32,\n\tuser bool?\n);\n"},
+        {"create table user(user int32) with (user=user)","CREATE TABLE user (\n\tuser int32\n)\nWITH (user = user);\n"},
+        {"create table user(primary key (user))","CREATE TABLE user (\n\tPRIMARY KEY (user)\n);\n"},
+        {"create table user(primary key (user,user))","CREATE TABLE user (\n\tPRIMARY KEY (user, user)\n);\n"},
+        {"create table user(partition by (user))","CREATE TABLE user (\n\tPARTITION BY (user)\n);\n"},
+        {"create table user(partition by (user,user))","CREATE TABLE user (\n\tPARTITION BY (user, user)\n);\n"},
+        {"create table user(order by (user asc))","CREATE TABLE user (\n\tORDER BY (user ASC)\n);\n"},
+        {"create table user(order by (user desc,user))","CREATE TABLE user (\n\tORDER BY (user DESC, user)\n);\n"},
+        {"create table user(user int32) with (ttl=interval('P1D') on user as seconds)",
+            "CREATE TABLE user (\n\tuser int32\n)\nWITH (ttl = interval('P1D') ON user AS SECONDS);\n"},
+        {"create table user(user int32) with (ttl=interval('P1D') on user as MilliSeconds)",
+            "CREATE TABLE user (\n\tuser int32\n)\nWITH (ttl = interval('P1D') ON user AS MILLISECONDS);\n"},
+        {"create table user(user int32) with (ttl=interval('P1D') on user as microSeconds)",
+            "CREATE TABLE user (\n\tuser int32\n)\nWITH (ttl = interval('P1D') ON user AS MICROSECONDS);\n"},
+        {"create table user(user int32) with (ttl=interval('P1D') on user as nAnOsEcOnDs)",
+            "CREATE TABLE user (\n\tuser int32\n)\nWITH (ttl = interval('P1D') ON user AS NANOSECONDS);\n"},
+        {"create table user(index user global unique sync on (user,user) with (user=user,user=user))",
+            "CREATE TABLE user (\n\tINDEX user GLOBAL UNIQUE SYNC ON (user, user) WITH (user = user, user = user)\n);\n"},
+        {"create table user(index user global async on (user) with (user=user,))",
+            "CREATE TABLE user (\n\tINDEX user GLOBAL ASYNC ON (user) WITH (user = user,)\n);\n"},
+        {"create table user(index user local on (user) cover (user))",
+            "CREATE TABLE user (\n\tINDEX user LOCAL ON (user) COVER (user)\n);\n"},
+        {"create table user(index user local on (user) cover (user,user))",
+            "CREATE TABLE user (\n\tINDEX user LOCAL ON (user) COVER (user, user)\n);\n"},
+        {"create table user(index idx global using subtype on (col) cover (col) with (setting = foo, another_setting = bar));",
+            "CREATE TABLE user (\n\tINDEX idx GLOBAL USING subtype ON (col) COVER (col) WITH (setting = foo, another_setting = bar)\n);\n"},
+        {"create table user(family user (user='foo'))",
+            "CREATE TABLE user (\n\tFAMILY user (user = 'foo')\n);\n"},
+        {"create table user(family user (user='foo',user='bar'))",
+            "CREATE TABLE user (\n\tFAMILY user (user = 'foo', user = 'bar')\n);\n"},
+        {"create table user(changefeed user with (user='foo'))",
+            "CREATE TABLE user (\n\tCHANGEFEED user WITH (user = 'foo')\n);\n"},
+        {"create table user(changefeed user with (user='foo',user='bar'))",
+            "CREATE TABLE user (\n\tCHANGEFEED user WITH (user = 'foo', user = 'bar')\n);\n"},
+        {"create table user(user) AS SELECT 1","CREATE TABLE user (\n\tuser\n)\nAS\nSELECT\n    1;\n"},
+        {"create table user(user) AS VALUES (1), (2)","CREATE TABLE user (\n\tuser\n)\nAS\nVALUES\n    (1),\n    (2);\n"},
+        {"create table user(foo int32, bar bool ?) inherits (s3:$cluster.xxx) partition by hash(a,b,hash) with (inherits=interval('PT1D') ON logical_time) tablestore tablestore",
+            "CREATE TABLE user (\n"
+            "\tfoo int32,\n"
+            "\tbar bool?\n"
+            ")\n"
+            "INHERITS (s3: $cluster.xxx)\n"
+            "PARTITION BY HASH (a, b, hash)\n"
+            "WITH (inherits = interval('PT1D') ON logical_time)\n"
+            "TABLESTORE tablestore;\n"},
+        {"create table user(foo int32, bar bool ?) partition by hash(a,b,hash) with (tiering='some')",
+            "CREATE TABLE user (\n"
+            "\tfoo int32,\n"
+            "\tbar bool?\n"
+            ")\n"
+            "PARTITION BY HASH (a, b, hash)\n"
+            "WITH (tiering = 'some');\n"},
+        {"create table if not  exists user(user int32)", "CREATE TABLE IF NOT EXISTS user (\n\tuser int32\n);\n"},
+        {"create temp   table    user(user int32)", "CREATE TEMP TABLE user (\n\tuser int32\n);\n"},
+        {"create   temporary   table    user(user int32)", "CREATE TEMPORARY TABLE user (\n\tuser int32\n);\n"}
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(ObjectOperations) {
+    TCases cases = {
+        {"alter oBject usEr (TYpe abcde) Set (a = b)",
+            "ALTER OBJECT usEr (TYPE abcde) SET (a = b);\n"},
+        {"creAte oBject usEr (tYpe abcde) With (a = b)",
+            "CREATE OBJECT usEr (TYPE abcde) WITH (a = b);\n"},
+            {"creAte oBject if not exIstS usEr (tYpe abcde) With (a = b)",
+            "CREATE OBJECT IF NOT EXISTS usEr (TYPE abcde) WITH (a = b);\n"},
+        {"creAte oBject usEr (tYpe abcde) With a = b",
+            "CREATE OBJECT usEr (TYPE abcde) WITH a = b;\n"},
+        {"dRop oBject usEr (tYpe abcde) With (aeEE)",
+            "DROP OBJECT usEr (TYPE abcde) WITH (aeEE);\n"},
+            {"dRop oBject If ExistS usEr (tYpe abcde) With (aeEE)",
+            "DROP OBJECT IF EXISTS usEr (TYPE abcde) WITH (aeEE);\n"},
+        {"dRop oBject usEr (tYpe abcde) With aeEE",
+            "DROP OBJECT usEr (TYPE abcde) WITH aeEE;\n"}
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(TableStoreOperations) {
+    TCases cases = {
+        {"alter tableStore uSer aDd column usEr int32",
+            "ALTER TABLESTORE uSer ADD COLUMN usEr int32;\n"},
+            {"alter tableStore uSer drOp column usEr",
+            "ALTER TABLESTORE uSer DROP COLUMN usEr;\n"}
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(ExternalDataSourceOperations) {
+    TCases cases = {
+        {"creAte exTernAl daTa SouRce usEr With (a = \"b\")",
+            "CREATE EXTERNAL DATA SOURCE usEr WITH (a = \"b\");\n"},
+            {"creAte exTernAl daTa SouRce if not exists usEr With (a = \"b\")",
+            "CREATE EXTERNAL DATA SOURCE IF NOT EXISTS usEr WITH (a = \"b\");\n"},
+            {"creAte oR rePlaCe exTernAl daTa SouRce usEr With (a = \"b\")",
+            "CREATE OR REPLACE EXTERNAL DATA SOURCE usEr WITH (a = \"b\");\n"},
+            {"create external data source eds with (a=\"a\",b=\"b\",c = true)",
+            "CREATE EXTERNAL DATA SOURCE eds WITH (\n\ta = \"a\",\n\tb = \"b\",\n\tc = TRUE\n);\n"},
+            {"alter external data source eds set a true, reset (b, c), set (x=y, z=false)",
+            "ALTER EXTERNAL DATA SOURCE eds\n\tSET a TRUE,\n\tRESET (b, c),\n\tSET (x = y, z = FALSE);\n"},
+            {"alter external data source eds reset (a), set (x=y)",
+            "ALTER EXTERNAL DATA SOURCE eds\n\tRESET (a),\n\tSET (x = y);\n"},
+        {"dRop exTerNal Data SouRce usEr",
+            "DROP EXTERNAL DATA SOURCE usEr;\n"},
+            {"dRop exTerNal Data SouRce if exists usEr",
+            "DROP EXTERNAL DATA SOURCE IF EXISTS usEr;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(AsyncReplication) {
+    TCases cases = {
+        {"create async replication user for table1 AS table2 with (user='foo')",
+            "CREATE ASYNC REPLICATION user FOR table1 AS table2 WITH (user = 'foo');\n"},
+        {"alter async replication user set (user='foo')",
+            "ALTER ASYNC REPLICATION user SET (user = 'foo');\n"},
+        {"drop async replication user",
+            "DROP ASYNC REPLICATION user;\n"},
+        {"drop async replication user cascade",
+            "DROP ASYNC REPLICATION user CASCADE;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(ExternalTableOperations) {
+    TCases cases = {
+        {"creAte exTernAl TabLe usEr (a int) With (a = \"b\")",
+            "CREATE EXTERNAL TABLE usEr (\n\ta int\n)\nWITH (a = \"b\");\n"},
+            {"creAte oR rePlaCe exTernAl TabLe usEr (a int) With (a = \"b\")",
+            "CREATE OR REPLACE EXTERNAL TABLE usEr (\n\ta int\n)\nWITH (a = \"b\");\n"},
+        {"creAte exTernAl TabLe iF NOt Exists usEr (a int) With (a = \"b\")",
+            "CREATE EXTERNAL TABLE IF NOT EXISTS usEr (\n\ta int\n)\nWITH (a = \"b\");\n"},
+        {"create external table user (a int) with (a=\"b\",c=\"d\")",
+            "CREATE EXTERNAL TABLE user (\n\ta int\n)\nWITH (\n\ta = \"b\",\n\tc = \"d\"\n);\n"},
+        {"alter  external table user add column col1 int32, drop column col2, reset(prop), set (prop2 = 42, x=y), set a true",
+        "ALTER EXTERNAL TABLE user\n\tADD COLUMN col1 int32,\n\tDROP COLUMN col2,\n\tRESET (prop),\n\tSET (prop2 = 42, x = y),\n\tSET a TRUE;\n"},
+        {"dRop exTerNal taBlE usEr",
+            "DROP EXTERNAL TABLE usEr;\n"},
+        {"dRop exTerNal taBlE iF eXiStS usEr",
+            "DROP EXTERNAL TABLE IF EXISTS usEr;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(TypeSelection) {
+    TCases cases = {
+        {"Select tYpe.* frOm Table tYpe",
+            "SELECT\n\ttYpe.*\nFROM Table\n\ttYpe;\n"}
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(AlterTable) {
+    TCases cases = {
+        {"alter table user add user int32",
+            "ALTER TABLE user\n\tADD user int32;\n"},
+        {"alter table user add user int32, add user bool ?",
+            "ALTER TABLE user\n\tADD user int32,\n\tADD user bool?;\n"},
+        {"alter table user add column user int32",
+            "ALTER TABLE user\n\tADD COLUMN user int32;\n"},
+        {"alter table user drop user",
+            "ALTER TABLE user\n\tDROP user;\n"},
+        {"alter table user drop column user",
+            "ALTER TABLE user\n\tDROP COLUMN user;\n"},
+        {"alter table user alter column user set family user",
+            "ALTER TABLE user\n\tALTER COLUMN user SET FAMILY user;\n"},
+        {"alter table t alter column c drop not null",
+            "ALTER TABLE t\n\tALTER COLUMN c DROP NOT NULL;\n"},
+        {"alter table user add family user(user='foo')",
+            "ALTER TABLE user\n\tADD FAMILY user (user = 'foo');\n"},
+        {"alter table user alter family user set user 'foo'",
+            "ALTER TABLE user\n\tALTER FAMILY user SET user 'foo';\n"},
+        {"alter table user set user user",
+            "ALTER TABLE user\n\tSET user user;\n"},
+        {"alter table user set (user=user)",
+            "ALTER TABLE user\n\tSET (user = user);\n"},
+        {"alter table user set (user=user,user=user)",
+            "ALTER TABLE user\n\tSET (user = user, user = user);\n"},
+        {"alter table user reset(user)",
+            "ALTER TABLE user\n\tRESET (user);\n"},
+        {"alter table user reset(user, user)",
+            "ALTER TABLE user\n\tRESET (user, user);\n"},
+        {"alter table user add index user local on (user)",
+            "ALTER TABLE user\n\tADD INDEX user LOCAL ON (user);\n"},
+        {"alter table user alter index idx set setting 'foo'",
+            "ALTER TABLE user\n\tALTER INDEX idx SET setting 'foo';\n"},
+        {"alter table user alter index idx set (setting = 'foo', another_setting = 'bar')",
+            "ALTER TABLE user\n\tALTER INDEX idx SET (setting = 'foo', another_setting = 'bar');\n"},
+        {"alter table user alter index idx reset (setting, another_setting)",
+            "ALTER TABLE user\n\tALTER INDEX idx RESET (setting, another_setting);\n"},
+        {"alter table user add index idx global using subtype on (col) cover (col) with (setting = foo, another_setting = 'bar');",
+            "ALTER TABLE user\n\tADD INDEX idx GLOBAL USING subtype ON (col) COVER (col) WITH (setting = foo, another_setting = 'bar');\n"},
+        {"alter table user drop index user",
+            "ALTER TABLE user\n\tDROP INDEX user;\n"},
+        {"alter table user rename to user",
+            "ALTER TABLE user\n\tRENAME TO user;\n"},
+        {"alter table user add changefeed user with (user = 'foo')",
+            "ALTER TABLE user\n\tADD CHANGEFEED user WITH (user = 'foo');\n"},
+        {"alter table user alter changefeed user disable",
+            "ALTER TABLE user\n\tALTER CHANGEFEED user DISABLE;\n"},
+        {"alter table user alter changefeed user set(user='foo')",
+            "ALTER TABLE user\n\tALTER CHANGEFEED user SET (user = 'foo');\n"},
+        {"alter table user drop changefeed user",
+            "ALTER TABLE user\n\tDROP CHANGEFEED user;\n"},
+        {"alter table user add changefeed user with (initial_scan = tRUe)",
+            "ALTER TABLE user\n\tADD CHANGEFEED user WITH (initial_scan = TRUE);\n"},
+        {"alter table user add changefeed user with (initial_scan = FaLsE)",
+            "ALTER TABLE user\n\tADD CHANGEFEED user WITH (initial_scan = FALSE);\n"},
+        {"alter table user add changefeed user with (retention_period = Interval(\"P1D\"))",
+            "ALTER TABLE user\n\tADD CHANGEFEED user WITH (retention_period = Interval(\"P1D\"));\n"},
+        {"alter table user add changefeed user with (virtual_timestamps = TruE)",
+            "ALTER TABLE user\n\tADD CHANGEFEED user WITH (virtual_timestamps = TRUE);\n"},
+        {"alter table user add changefeed user with (virtual_timestamps = fAlSe)",
+            "ALTER TABLE user\n\tADD CHANGEFEED user WITH (virtual_timestamps = FALSE);\n"},
+        {"alter table user add changefeed user with (resolved_timestamps = Interval(\"PT1S\"))",
+            "ALTER TABLE user\n\tADD CHANGEFEED user WITH (resolved_timestamps = Interval(\"PT1S\"));\n"},
+        {"alter table user add changefeed user with (topic_min_active_partitions = 1)",
+            "ALTER TABLE user\n\tADD CHANGEFEED user WITH (topic_min_active_partitions = 1);\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(CreateTopic) {
+    TCases cases = {
+        {"create topic topic1",
+            "CREATE TOPIC topic1;\n"},
+            {"create topic topic1 (consumer c1)",
+            "CREATE TOPIC topic1 (\n\tCONSUMER c1\n);\n"},
+            {"create topic topic1 (consumer c1, consumer c2 with (important = True))",
+            "CREATE TOPIC topic1 (\n\tCONSUMER c1,\n\tCONSUMER c2 WITH (important = TRUE)\n);\n"},
+            {"create topic topic1 (consumer c1) with (partition_count_limit = 5)",
+            "CREATE TOPIC topic1 (\n\tCONSUMER c1\n) WITH (\n\tpartition_count_limit = 5\n);\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(AlterTopic) {
+    TCases cases = {
+            {"alter topic topic1 alter consumer c1 set (important = false)",
+            "ALTER TOPIC topic1\n\tALTER CONSUMER c1 SET (important = FALSE);\n"},
+            {"alter topic topic1 alter consumer c1 set (important = false), alter consumer c2 reset (read_from)",
+            "ALTER TOPIC topic1\n\tALTER CONSUMER c1 SET (important = FALSE),\n\tALTER CONSUMER c2 RESET (read_from);\n"},
+            {"alter topic topic1 add consumer c1, drop consumer c2",
+            "ALTER TOPIC topic1\n\tADD CONSUMER c1,\n\tDROP CONSUMER c2;\n"},
+            {"alter topic topic1 set (supported_codecs = 'RAW'), RESET (retention_period)",
+            "ALTER TOPIC topic1\n\tSET (supported_codecs = 'RAW'),\n\tRESET (retention_period);\n"},
+
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(DropTopic) {
+    TCases cases = {
+        {"drop topic topic1",
+            "DROP TOPIC topic1;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(TopicExistsStatement) {
+    TCases cases = {
+        {"drop topic if exists topic1",
+            "DROP TOPIC IF EXISTS topic1;\n"},
+        {"create topic if not exists topic1 with (partition_count_limit = 5)",
+            "CREATE TOPIC IF NOT EXISTS topic1 WITH (\n\tpartition_count_limit = 5\n);\n"},
+            {"alter topic if exists topic1 alter consumer c1 set (important = false)",
+            "ALTER TOPIC IF EXISTS topic1\n\tALTER CONSUMER c1 SET (important = FALSE);\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(Do) {
+    TCases cases = {
+        {"do $a(1,2,3)",
+            "DO $a(1, 2, 3);\n"},
+        {"do begin values(1); end do;",
+            "DO BEGIN\n\tVALUES\n\t\t(1);\nEND DO;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(DefineActionOrSubquery) {
+    TCases cases = {
+        {"define action $a() as "
+            "define action $b() as "
+            "values(1); "
+            "end define; "
+            "define subquery $c() as "
+            "select 1; "
+            "end define; "
+            "do $b(); "
+            "process $c(); "
+            "end define",
+            "DEFINE ACTION $a() AS\n\tDEFINE ACTION $b() AS\n\t\t"
+            "VALUES\n\t\t\t(1);\n\tEND DEFINE;\n\n\t"
+            "DEFINE SUBQUERY $c() AS\n\t\tSELECT\n\t\t\t1;\n\t"
+            "END DEFINE;\n\tDO $b();\n\n\tPROCESS $c();\nEND DEFINE;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(If) {
+    TCases cases = {
+        {"evaluate if 1=1 do $a()",
+            "EVALUATE IF 1 = 1\n\tDO $a();\n"},
+        {"evaluate if 1=1 do $a() else do $b()",
+            "EVALUATE IF 1 = 1\n\tDO $a()\nELSE\n\tDO $b();\n"},
+        {"evaluate if 1=1 do begin select 1; end do",
+            "EVALUATE IF 1 = 1\n\tDO BEGIN\n\t\tSELECT\n\t\t\t1;\n\tEND DO;\n"},
+        {"evaluate if 1=1 do begin select 1; end do else do begin select 2; end do",
+            "EVALUATE IF 1 = 1\n\tDO BEGIN\n\t\tSELECT\n\t\t\t1;\n\tEND DO\n"
+            "ELSE\n\tDO BEGIN\n\t\tSELECT\n\t\t\t2;\n\tEND DO;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(For) {
+    TCases cases = {
+        {"evaluate for $x in [] do $a($x)",
+            "EVALUATE FOR $x IN []\n\tDO $a($x);\n"},
+        {"evaluate for $x in [] do $a($x) else do $b()",
+            "EVALUATE FOR $x IN []\n\tDO $a($x)\nELSE\n\tDO $b();\n"},
+        {"evaluate for $x in [] do begin select $x; end do",
+            "EVALUATE FOR $x IN []\n\tDO BEGIN\n\t\tSELECT\n\t\t\t$x;\n\tEND DO;\n"},
+        {"evaluate for $x in [] do begin select $x; end do else do begin select 2; end do",
+            "EVALUATE FOR $x IN []\n\tDO BEGIN\n\t\tSELECT\n\t\t\t$x;\n\tEND DO\nELSE\n\tDO BEGIN\n\t\tSELECT\n\t\t\t2;\n\tEND DO;\n"},
+        {"evaluate parallel for $x in [] do $a($x)",
+            "EVALUATE PARALLEL FOR $x IN []\n\tDO $a($x);\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(Update) {
+    TCases cases = {
+        {"update user on default values",
+            "UPDATE user\nON DEFAULT VALUES;\n"},
+        {"update user on values (1),(2)",
+            "UPDATE user\nON\nVALUES\n\t(1),\n\t(2);\n"},
+        {"update user on select 1 as x, 2 as y",
+            "UPDATE user\nON\nSELECT\n\t1 AS x,\n\t2 AS y;\n"},
+        {"update user on (x) values (1),(2),(3)",
+            "UPDATE user\nON (\n\tx\n)\nVALUES\n\t(1),\n\t(2),\n\t(3);\n"},
+        {"update user on (x,y) values (1,2),(2,3),(3,4)",
+            "UPDATE user\nON (\n\tx,\n\ty\n)\nVALUES\n\t(1, 2),\n\t(2, 3),\n\t(3, 4);\n"},
+        {"update user on (x) select 1",
+            "UPDATE user\nON (\n\tx\n)\nSELECT\n\t1;\n"},
+        {"update user on (x,y) select 1,2",
+            "UPDATE user\nON (\n\tx,\n\ty\n)\nSELECT\n\t1,\n\t2;\n"},
+        {"update user set x=1",
+            "UPDATE user\nSET\n\tx = 1;\n"},
+        {"update user set (x)=(1)",
+            "UPDATE user\nSET\n(\n\tx\n) = (\n\t1\n);\n"},
+        {"update user set (x,y)=(1,2)",
+            "UPDATE user\nSET\n(\n\tx,\n\ty\n) = (\n\t1,\n\t2\n);\n"},
+        {"update user set (x,y)=(select 1,2)",
+            "UPDATE user\nSET\n(\n\tx,\n\ty\n) = (\n\tSELECT\n\t\t1,\n\t\t2\n);\n"},
+        {"update user set x=1,y=2 where z=3",
+            "UPDATE user\nSET\n\tx = 1,\n\ty = 2\nWHERE z = 3;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(Delete) {
+    TCases cases = {
+        {"delete from user",
+            "DELETE FROM user;\n"},
+        {"delete from user where 1=1",
+            "DELETE FROM user\nWHERE 1 = 1;\n"},
+        {"delete from user on select 1 as x, 2 as y",
+            "DELETE FROM user\nON\nSELECT\n\t1 AS x,\n\t2 AS y;\n"},
+        {"delete from user on (x) values (1)",
+            "DELETE FROM user\nON (\n\tx\n)\nVALUES\n\t(1);\n"},
+        {"delete from user on (x,y) values (1,2), (3,4)",
+            "DELETE FROM user\nON (\n\tx,\n\ty\n)\nVALUES\n\t(1, 2),\n\t(3, 4);\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(Into) {
+    TCases cases = {
+        {"insert into user select 1 as x",
+            "INSERT INTO user\nSELECT\n\t1 AS x;\n"},
+        {"insert or abort into user select 1 as x",
+            "INSERT OR ABORT INTO user\nSELECT\n\t1 AS x;\n"},
+        {"insert or revert into user select 1 as x",
+            "INSERT OR REVERT INTO user\nSELECT\n\t1 AS x;\n"},
+        {"insert or ignore into user select 1 as x",
+            "INSERT OR IGNORE INTO user\nSELECT\n\t1 AS x;\n"},
+        {"upsert into user select 1 as x",
+            "UPSERT INTO user\nSELECT\n\t1 AS x;\n"},
+        {"replace into user select 1 as x",
+            "REPLACE INTO user\nSELECT\n\t1 AS x;\n"},
+        {"insert into user(x) values (1)",
+            "INSERT INTO user (\n\tx\n)\nVALUES\n\t(1);\n"},
+        {"insert into user(x,y) values (1,2)",
+            "INSERT INTO user (\n\tx,\n\ty\n)\nVALUES\n\t(1, 2);\n"},
+        {"insert into plato.user select 1 as x",
+            "INSERT INTO plato.user\nSELECT\n\t1 AS x;\n"},
+        {"insert into @user select 1 as x",
+            "INSERT INTO @user\nSELECT\n\t1 AS x;\n"},
+        {"insert into $user select 1 as x",
+            "INSERT INTO $user\nSELECT\n\t1 AS x;\n"},
+        {"insert into @$user select 1 as x",
+            "INSERT INTO @$user\nSELECT\n\t1 AS x;\n"},
+        {"upsert into user erase by (x,y) values (1)",
+            "UPSERT INTO user\n\tERASE BY (\n\t\tx,\n\t\ty\n\t)\nVALUES\n\t(1);\n"},
+        {"insert into user with truncate select 1 as x",
+            "INSERT INTO user\n\tWITH truncate\nSELECT\n\t1 AS x;\n"},
+        {"insert into user with (truncate,inferscheme='1') select 1 as x",
+            "INSERT INTO user\n\tWITH (truncate, inferscheme = '1')\nSELECT\n\t1 AS x;\n"},
+        {"insert into user with schema Struct<user:int32> select 1 as user",
+            "INSERT INTO user\n\tWITH SCHEMA Struct<user: int32>\nSELECT\n\t1 AS user;\n"},
+        {"insert into user with schema (int32 as user) select 1 as user",
+            "INSERT INTO user\n\tWITH SCHEMA (int32 AS user)\nSELECT\n\t1 AS user;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(Process) {
+    TCases cases = {
+        {"process user",
+            "PROCESS user;\n"},
+        {"process user using $f() as user",
+            "PROCESS user\nUSING $f() AS user;\n"},
+        {"process user,user using $f()",
+            "PROCESS user, user\nUSING $f();\n"},
+        {"process user using $f() where 1=1 having 1=1 assume order by user",
+            "PROCESS user\nUSING $f()\nWHERE 1 = 1\nHAVING 1 = 1\nASSUME ORDER BY\n\tuser;\n"},
+        {"process user using $f() union all process user using $f()",
+            "PROCESS user\nUSING $f()\nUNION ALL\nPROCESS user\nUSING $f();\n"},
+        {"process user using $f() with foo=bar",
+            "PROCESS user\nUSING $f()\nWITH foo = bar;\n"},
+        {"discard process user using $f()",
+            "DISCARD PROCESS user\nUSING $f();\n"},
+        {"process user using $f() into result user",
+            "PROCESS user\nUSING $f()\nINTO RESULT user;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(Reduce) {
+    TCases cases = {
+        {"reduce user on user using $f()",
+            "REDUCE user\nON\n\tuser\nUSING $f();\n"},
+        {"reduce user on user, using $f()",
+            "REDUCE user\nON\n\tuser,\nUSING $f();\n"},
+        {"discard reduce user on user using $f();",
+            "DISCARD REDUCE user\nON\n\tuser\nUSING $f();\n"},
+        {"reduce user on user using $f() into result user",
+            "REDUCE user\nON\n\tuser\nUSING $f()\nINTO RESULT user;\n"},
+        {"reduce user on user using all $f()",
+            "REDUCE user\nON\n\tuser\nUSING ALL $f();\n"},
+        {"reduce user on user using $f() as user",
+            "REDUCE user\nON\n\tuser\nUSING $f() AS user;\n"},
+        {"reduce user,user on user using $f()",
+            "REDUCE user, user\nON\n\tuser\nUSING $f();\n"},
+        {"reduce user on user,user using $f()",
+            "REDUCE user\nON\n\tuser,\n\tuser\nUSING $f();\n"},
+        {"reduce user on user using $f() where 1=1 having 1=1 assume order by user",
+            "REDUCE user\nON\n\tuser\nUSING $f()\nWHERE 1 = 1\nHAVING 1 = 1\nASSUME ORDER BY\n\tuser;\n"},
+        {"reduce user presort user,user on user using $f();",
+            "REDUCE user\nPRESORT\n\tuser,\n\tuser\nON\n\tuser\nUSING $f();\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(Select) {
+    TCases cases = {
+        {"select 1",
+            "SELECT\n\t1;\n"},
+        {"select 1,",
+            "SELECT\n\t1,;\n"},
+        {"select 1 as x",
+            "SELECT\n\t1 AS x;\n"},
+        {"select *",
+            "SELECT\n\t*;\n"},
+        {"select a.*",
+            "SELECT\n\ta.*;\n"},
+        {"select * without a",
+            "SELECT\n\t*\n\tWITHOUT\n\t\ta;\n"},
+        {"select * without a,b",
+            "SELECT\n\t*\n\tWITHOUT\n\t\ta,\n\t\tb;\n"},
+        {"select * without a,",
+            "SELECT\n\t*\n\tWITHOUT\n\t\ta,;\n"},
+        {"select 1 from user",
+            "SELECT\n\t1\nFROM user;\n"},
+        {"select 1 from plato.user",
+            "SELECT\n\t1\nFROM plato.user;\n"},
+        {"select 1 from $user",
+            "SELECT\n\t1\nFROM $user;\n"},
+        {"select 1 from @user",
+            "SELECT\n\t1\nFROM @user;\n"},
+        {"select 1 from @$user",
+            "SELECT\n\t1\nFROM @$user;\n"},
+        {"select 1 from user view user",
+            "SELECT\n\t1\nFROM user\n\tVIEW user;\n"},
+        {"select 1 from user as user",
+            "SELECT\n\t1\nFROM user\n\tAS user;\n"},
+        {"select 1 from user as user(user)",
+            "SELECT\n\t1\nFROM user\n\tAS user (\n\t\tuser\n\t);\n"},
+        {"select 1 from user as user(user, user)",
+            "SELECT\n\t1\nFROM user\n\tAS user (\n\t\tuser,\n\t\tuser\n\t);\n"},
+        {"select 1 from user with user=user",
+            "SELECT\n\t1\nFROM user\n\tWITH user = user;\n"},
+        {"select 1 from user with (user=user, user=user)",
+            "SELECT\n\t1\nFROM user\n\tWITH (user = user, user = user);\n"},
+        {"select 1 from user sample 0.1",
+            "SELECT\n\t1\nFROM user\n\tSAMPLE 0.1;\n"},
+        {"select 1 from user tablesample system(0.1)",
+            "SELECT\n\t1\nFROM user\n\tTABLESAMPLE SYSTEM (0.1);\n"},
+        {"select 1 from user tablesample bernoulli(0.1) repeatable(10)",
+            "SELECT\n\t1\nFROM user\n\tTABLESAMPLE BERNOULLI (0.1) REPEATABLE (10);\n"},
+        {"select 1 from user flatten columns",
+            "SELECT\n\t1\nFROM user\n\tFLATTEN COLUMNS;\n"},
+        {"select 1 from user flatten list by user",
+            "SELECT\n\t1\nFROM user\n\tFLATTEN LIST BY\n\t\tuser;\n"},
+        {"select 1 from user flatten list by (user,user)",
+            "SELECT\n\t1\nFROM user\n\tFLATTEN LIST BY (\n\t\tuser,\n\t\tuser\n\t);\n"},
+        {"select 1 from $user(1,2)",
+            "SELECT\n\t1\nFROM $user(1, 2);\n"},
+        {"select 1 from $user(1,2) view user",
+            "SELECT\n\t1\nFROM $user(1, 2)\n\tVIEW user;\n"},
+        {"select 1 from range('a','b')",
+            "SELECT\n\t1\nFROM range('a', 'b');\n"},
+        {"from user select 1",
+            "FROM user\nSELECT\n\t1;\n"},
+        {"select * from user as a join user as b on a.x=b.y",
+            "SELECT\n\t*\nFROM user\n\tAS a\nJOIN user\n\tAS b\nON a.x = b.y;\n"},
+        {"select * from user as a join user as b using(x)",
+            "SELECT\n\t*\nFROM user\n\tAS a\nJOIN user\n\tAS b\nUSING (x);\n"},
+        {"select * from any user as a full join user as b on a.x=b.y",
+            "SELECT\n\t*\nFROM ANY user\n\tAS a\nFULL JOIN user\n\tAS b\nON a.x = b.y;\n"},
+        {"select * from user as a left join any user as b on a.x=b.y",
+            "SELECT\n\t*\nFROM user\n\tAS a\nLEFT JOIN ANY user\n\tAS b\nON a.x = b.y;\n"},
+        {"select * from any user as a right join any user as b on a.x=b.y",
+            "SELECT\n\t*\nFROM ANY user\n\tAS a\nRIGHT JOIN ANY user\n\tAS b\nON a.x = b.y;\n"},
+        {"select * from user as a cross join user as b",
+            "SELECT\n\t*\nFROM user\n\tAS a\nCROSS JOIN user\n\tAS b;\n"},
+        {"select 1 from user where key = 1",
+            "SELECT\n\t1\nFROM user\nWHERE key = 1;\n"},
+        {"select 1 from user having count(*) = 1",
+            "SELECT\n\t1\nFROM user\nHAVING count(*) = 1;\n"},
+        {"select 1 from user group by key",
+            "SELECT\n\t1\nFROM user\nGROUP BY\n\tkey;\n"},
+        {"select 1 from user group compact by key, value as v",
+            "SELECT\n\t1\nFROM user\nGROUP COMPACT BY\n\tkey,\n\tvalue AS v;\n"},
+        {"select 1 from user group by key with combine",
+            "SELECT\n\t1\nFROM user\nGROUP BY\n\tkey\n\tWITH combine;\n"},
+        {"select 1 from user order by key asc",
+            "SELECT\n\t1\nFROM user\nORDER BY\n\tkey ASC;\n"},
+        {"select 1 from user order by key, value desc",
+            "SELECT\n\t1\nFROM user\nORDER BY\n\tkey,\n\tvalue DESC;\n"},
+        {"select 1 from user assume order by key",
+            "SELECT\n\t1\nFROM user\nASSUME ORDER BY\n\tkey;\n"},
+        {"select 1 from user window w1 as (), w2 as ()",
+            "SELECT\n\t1\nFROM user\nWINDOW\n\tw1 AS (),\n\tw2 AS ();\n"},
+        {"select 1 from user window w1 as (user)",
+            "SELECT\n\t1\nFROM user\nWINDOW\n\tw1 AS (\n\t\tuser\n\t);\n"},
+        {"select 1 from user window w1 as (partition by user)",
+            "SELECT\n\t1\nFROM user\nWINDOW\n\tw1 AS (\n\t\tPARTITION BY\n\t\t\tuser\n\t);\n"},
+        {"select 1 from user window w1 as (partition by user, user)",
+            "SELECT\n\t1\nFROM user\nWINDOW\n\tw1 AS (\n\t\tPARTITION BY\n\t\t\tuser,\n\t\t\tuser\n\t);\n"},
+        {"select 1 from user window w1 as (order by user asc)",
+            "SELECT\n\t1\nFROM user\nWINDOW\n\tw1 AS (\n\t\tORDER BY\n\t\t\tuser ASC\n\t);\n"},
+        {"select 1 from user window w1 as (order by user, user desc)",
+            "SELECT\n\t1\nFROM user\nWINDOW\n\tw1 AS (\n\t\tORDER BY\n\t\t\tuser,\n\t\t\tuser DESC\n\t);\n"},
+        {"select 1 from user window w1 as (rows between 1 preceding and 1 following)",
+            "SELECT\n\t1\nFROM user\nWINDOW\n\tw1 AS (\n\t\tROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING\n\t);\n"},
+        {"select 1 limit 10",
+            "SELECT\n\t1\nLIMIT 10;\n"},
+        {"select 1 limit 10 offset 5",
+            "SELECT\n\t1\nLIMIT 10 OFFSET 5;\n"},
+        { "select 1 union all select 2",
+            "SELECT\n\t1\nUNION ALL\nSELECT\n\t2;\n" },
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(CompositeTypesAndQuestions) {
+    TCases cases = {
+        {"declare $_x AS list<int32>??;declare $_y AS int32 ? ? ;select 1<>2, 1??2,"
+            "formattype(list<int32>), formattype(resource<user>),formattype(tuple<>), formattype(tuple<  >), formattype(int32 ? ? )",
+            "DECLARE $_x AS list<int32>??;\nDECLARE $_y AS int32??;\n\nSELECT\n\t1 <> 2,\n\t1 ?? 2,\n\tformattype(list<int32>),"
+        "\n\tformattype(resource<user>),\n\tformattype(tuple<>),\n\tformattype(tuple< >),\n\tformattype(int32??" ");\n"
+        },
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(Lambda) {
+    TCases cases = {
+        {"$f=($a,$b)->{$x=$a+$b;return $a*$x};$g=($a,$b?)->($a+$b??0);select $f(10,4),$g(1,2);",
+            "$f = ($a, $b) -> {\n\t$x = $a + $b;\n\tRETURN $a * $x\n};\n"
+            "$g = ($a, $b?) -> ($a + $b ?? 0);\n\n"
+        "SELECT\n\t$f(10, 4),\n\t$g(1, 2);\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(NestedSelect) {
+    TCases cases = {
+        {"$x=select 1",
+            "$x =\n\tSELECT\n\t\t1;\n"},
+        {"$x=(select 1)",
+            "$x = (\n\tSELECT\n\t\t1\n);\n"},
+        {"select 1 in (select 1)",
+            "SELECT\n\t1 IN (\n\t\tSELECT\n\t\t\t1\n\t);\n"},
+        {"select 1 in ((select 1))",
+            "SELECT\n\t1 IN (\n\t\t(\n\t\t\tSELECT\n\t\t\t\t1\n\t\t)\n\t);\n"},
+        {"select 1 in (\nselect 1)",
+            "SELECT\n\t1 IN (\n\t\tSELECT\n\t\t\t1\n\t);\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(Cast) {
+    TCases cases = {
+        {"select cast(1 as string)","SELECT\n\tCAST(1 AS string);\n"},
+        {"select bitcast(1 as int32)","SELECT\n\tBITCAST(1 AS int32);\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(StructLiteral) {
+    TCases cases = {
+        {"select <||>","SELECT\n\t<||>;\n"},
+        {"select <|a:1|>","SELECT\n\t<|a: 1|>;\n"},
+        {"select <|a:1,b:2|>","SELECT\n\t<|a: 1, b: 2|>;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(TableHints) {
+    TCases cases = {
+        {"select * from plato.T with schema(foo int32, bar list<string>) where key is not null",
+            "SELECT\n\t*\nFROM plato.T\n\tWITH SCHEMA (foo int32, bar list<string>)\nWHERE key IS NOT NULL;\n"},
+        {"select * from plato.T with schema struct<foo:integer, Bar:list<string?>> where key<0",
+            "SELECT\n\t*\nFROM plato.T\n\tWITH SCHEMA struct<foo: integer, Bar: list<string?>>\nWHERE key < 0;\n"},
+        {"select * from plato.T with (foo=bar, x=$y, a=(a, b, c), u='aaa', schema (foo int32, bar list<string>))",
+            "SELECT\n\t*\nFROM plato.T\n\tWITH (foo = bar, x = $y, a = (a, b, c), u = 'aaa', SCHEMA (foo int32, bar list<string>));\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(BoolAsVariableName) {
+    TCases cases = {
+        {"$ False = True; select $ False;",
+            "$False = TRUE;\n\nSELECT\n\t$False;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(WithSchemaEquals) {
+    TCases cases = {
+        {"select * from plato.T with (format= csv_with_names, schema=(year int32 Null, month String, day String not   null, a Utf8, b Uint16));",
+            "SELECT\n\t*\nFROM plato.T\n\tWITH (format = csv_with_names, SCHEMA = (year int32 NULL, month String, day String NOT NULL, a Utf8, b Uint16));\n"},
+            };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(SquareBrackets) {
+    TCases cases = {
+        {"select a[0]",
+            "SELECT\n\ta[0];\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(MultiLineList) {
+    TCases cases = {
+        {"select [\n]",
+            "SELECT\n\t[\n\t];\n"},
+        {"select [1\n]",
+            "SELECT\n\t[\n\t\t1\n\t];\n"},
+        {"select [\n1]",
+            "SELECT\n\t[\n\t\t1\n\t];\n"},
+        {"select [1,\n]",
+            "SELECT\n\t[\n\t\t1,\n\t];\n"},
+        {"select [1\n,]",
+            "SELECT\n\t[\n\t\t1,\n\t];\n"},
+        {"select [\n1,]",
+            "SELECT\n\t[\n\t\t1,\n\t];\n"},
+        {"select [1,2,\n3,4]",
+            "SELECT\n\t[\n\t\t1, 2,\n\t\t3, 4\n\t];\n"},
+        {"select [1,2,\n3,4,]",
+            "SELECT\n\t[\n\t\t1, 2,\n\t\t3, 4,\n\t];\n"},
+        {"select [1,2\n,3,\n4\n,5]",
+            "SELECT\n\t[\n\t\t1, 2,\n\t\t3,\n\t\t4,\n\t\t5\n\t];\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(MultiLineTuple) {
+    TCases cases = {
+        {"select (\n)",
+            "SELECT\n\t(\n\t);\n"},
+        {"select (1,\n)",
+            "SELECT\n\t(\n\t\t1,\n\t);\n"},
+        {"select (1\n,)",
+            "SELECT\n\t(\n\t\t1,\n\t);\n"},
+        {"select (\n1,)",
+            "SELECT\n\t(\n\t\t1,\n\t);\n"},
+        {"select (1,2,\n3,4)",
+            "SELECT\n\t(\n\t\t1, 2,\n\t\t3, 4\n\t);\n"},
+        {"select (1,2,\n3,4,)",
+            "SELECT\n\t(\n\t\t1, 2,\n\t\t3, 4,\n\t);\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(MultiLineSet) {
+    TCases cases = {
+        {"select {\n}",
+            "SELECT\n\t{\n\t};\n"},
+        {"select {1\n}",
+            "SELECT\n\t{\n\t\t1\n\t};\n"},
+        {"select {\n1}",
+            "SELECT\n\t{\n\t\t1\n\t};\n"},
+        {"select {1,\n}",
+            "SELECT\n\t{\n\t\t1,\n\t};\n"},
+        {"select {1\n,}",
+            "SELECT\n\t{\n\t\t1,\n\t};\n"},
+        {"select {\n1,}",
+            "SELECT\n\t{\n\t\t1,\n\t};\n"},
+        {"select {1,2,\n3,4}",
+            "SELECT\n\t{\n\t\t1, 2,\n\t\t3, 4\n\t};\n"},
+        {"select {1,2,\n3,4,}",
+            "SELECT\n\t{\n\t\t1, 2,\n\t\t3, 4,\n\t};\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(MultiLineDict) {
+    TCases cases = {
+        {"select {0:1\n}",
+            "SELECT\n\t{\n\t\t0: 1\n\t};\n"},
+        {"select {\n0:1}",
+            "SELECT\n\t{\n\t\t0: 1\n\t};\n"},
+        {"select {0:1,\n}",
+            "SELECT\n\t{\n\t\t0: 1,\n\t};\n"},
+        {"select {0:1\n,}",
+            "SELECT\n\t{\n\t\t0: 1,\n\t};\n"},
+        {"select {\n0:1,}",
+            "SELECT\n\t{\n\t\t0: 1,\n\t};\n"},
+        {"select {10:1,20:2,\n30:3,40:4}",
+            "SELECT\n\t{\n\t\t10: 1, 20: 2,\n\t\t30: 3, 40: 4\n\t};\n"},
+        {"select {10:1,20:2,\n30:3,40:4,}",
+            "SELECT\n\t{\n\t\t10: 1, 20: 2,\n\t\t30: 3, 40: 4,\n\t};\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(MultiLineFuncCall) {
+    TCases cases = {
+        {"select f(\n)",
+            "SELECT\n\tf(\n\t);\n"},
+        {"select f(1\n)",
+            "SELECT\n\tf(\n\t\t1\n\t);\n"},
+        {"select f(\n1)",
+            "SELECT\n\tf(\n\t\t1\n\t);\n"},
+        {"select f(1,\n)",
+            "SELECT\n\tf(\n\t\t1,\n\t);\n"},
+        {"select f(1\n,)",
+            "SELECT\n\tf(\n\t\t1,\n\t);\n"},
+        {"select f(\n1,)",
+            "SELECT\n\tf(\n\t\t1,\n\t);\n"},
+        {"select f(1,2,\n3,4)",
+            "SELECT\n\tf(\n\t\t1, 2,\n\t\t3, 4\n\t);\n"},
+        {"select f(1,2,\n3,4,)",
+            "SELECT\n\tf(\n\t\t1, 2,\n\t\t3, 4,\n\t);\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(MultiLineStruct) {
+    TCases cases = {
+        {"select <|\n|>",
+            "SELECT\n\t<|\n\t|>;\n"},
+        {"select <|a:1\n|>",
+            "SELECT\n\t<|\n\t\ta: 1\n\t|>;\n"},
+        {"select <|\na:1|>",
+            "SELECT\n\t<|\n\t\ta: 1\n\t|>;\n"},
+        {"select <|a:1,\n|>",
+            "SELECT\n\t<|\n\t\ta: 1,\n\t|>;\n"},
+        {"select <|a:1\n,|>",
+            "SELECT\n\t<|\n\t\ta: 1,\n\t|>;\n"},
+        {"select <|\na:1,|>",
+            "SELECT\n\t<|\n\t\ta: 1,\n\t|>;\n"},
+        {"select <|a:1,b:2,\nc:3,d:4|>",
+            "SELECT\n\t<|\n\t\ta: 1, b: 2,\n\t\tc: 3, d: 4\n\t|>;\n"},
+        {"select <|a:1,b:2,\nc:3,d:4,|>",
+            "SELECT\n\t<|\n\t\ta: 1, b: 2,\n\t\tc: 3, d: 4,\n\t|>;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(MultiLineListType) {
+    TCases cases = {
+        {"select list<int32\n>",
+            "SELECT\n\tlist<\n\t\tint32\n\t>;\n"},
+        {"select list<\nint32>",
+            "SELECT\n\tlist<\n\t\tint32\n\t>;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(MultiLineOptionalType) {
+    TCases cases = {
+        {"select optional<int32\n>",
+            "SELECT\n\toptional<\n\t\tint32\n\t>;\n"},
+        {"select optional<\nint32>",
+            "SELECT\n\toptional<\n\t\tint32\n\t>;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(MultiLineStreamType) {
+    TCases cases = {
+        {"select stream<int32\n>",
+            "SELECT\n\tstream<\n\t\tint32\n\t>;\n"},
+        {"select stream<\nint32>",
+            "SELECT\n\tstream<\n\t\tint32\n\t>;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(MultiLineFlowType) {
+    TCases cases = {
+        {"select flow<int32\n>",
+            "SELECT\n\tflow<\n\t\tint32\n\t>;\n"},
+        {"select flow<\nint32>",
+            "SELECT\n\tflow<\n\t\tint32\n\t>;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(MultiLineSetType) {
+    TCases cases = {
+        {"select set<int32\n>",
+            "SELECT\n\tset<\n\t\tint32\n\t>;\n"},
+        {"select set<\nint32>",
+            "SELECT\n\tset<\n\t\tint32\n\t>;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(MultiLineTupleType) {
+    TCases cases = {
+        {"select tuple<\n>",
+            "SELECT\n\ttuple<\n\t\t \n\t>;\n"},
+        {"select tuple<int32\n>",
+            "SELECT\n\ttuple<\n\t\tint32\n\t>;\n"},
+        {"select tuple<\nint32>",
+            "SELECT\n\ttuple<\n\t\tint32\n\t>;\n"},
+        {"select tuple<int32,\n>",
+            "SELECT\n\ttuple<\n\t\tint32,\n\t>;\n"},
+        {"select tuple<int32\n,>",
+            "SELECT\n\ttuple<\n\t\tint32,\n\t>;\n"},
+        {"select tuple<\nint32,>",
+            "SELECT\n\ttuple<\n\t\tint32,\n\t>;\n"},
+        {"select tuple<\nint32,string,\ndouble,bool>",
+            "SELECT\n\ttuple<\n\t\tint32, string,\n\t\tdouble, bool\n\t>;\n"},
+        {"select tuple<\nint32,string,\ndouble,bool,>",
+            "SELECT\n\ttuple<\n\t\tint32, string,\n\t\tdouble, bool,\n\t>;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(MultiLineStructType) {
+    TCases cases = {
+        {"select struct<\n>",
+            "SELECT\n\tstruct<\n\t\t \n\t>;\n"},
+        {"select struct<a:int32\n>",
+            "SELECT\n\tstruct<\n\t\ta: int32\n\t>;\n"},
+        {"select struct<\na:int32>",
+            "SELECT\n\tstruct<\n\t\ta: int32\n\t>;\n"},
+        {"select struct<a:int32,\n>",
+            "SELECT\n\tstruct<\n\t\ta: int32,\n\t>;\n"},
+        {"select struct<a:int32\n,>",
+            "SELECT\n\tstruct<\n\t\ta: int32,\n\t>;\n"},
+        {"select struct<\na:int32,>",
+            "SELECT\n\tstruct<\n\t\ta: int32,\n\t>;\n"},
+        {"select struct<\na:int32,b:string,\nc:double,d:bool>",
+            "SELECT\n\tstruct<\n\t\ta: int32, b: string,\n\t\tc: double, d: bool\n\t>;\n"},
+        {"select struct<\na:int32,b:string,\nc:double,d:bool,>",
+            "SELECT\n\tstruct<\n\t\ta: int32, b: string,\n\t\tc: double, d: bool,\n\t>;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(MultiLineVariantOverTupleType) {
+    TCases cases = {
+        {"select variant<int32\n>",
+            "SELECT\n\tvariant<\n\t\tint32\n\t>;\n"},
+        {"select variant<\nint32>",
+            "SELECT\n\tvariant<\n\t\tint32\n\t>;\n"},
+        {"select variant<int32,\n>",
+            "SELECT\n\tvariant<\n\t\tint32,\n\t>;\n"},
+        {"select variant<int32\n,>",
+            "SELECT\n\tvariant<\n\t\tint32,\n\t>;\n"},
+        {"select variant<\nint32,>",
+            "SELECT\n\tvariant<\n\t\tint32,\n\t>;\n"},
+        {"select variant<\nint32,string,\ndouble,bool>",
+            "SELECT\n\tvariant<\n\t\tint32, string,\n\t\tdouble, bool\n\t>;\n"},
+        {"select variant<\nint32,string,\ndouble,bool,>",
+            "SELECT\n\tvariant<\n\t\tint32, string,\n\t\tdouble, bool,\n\t>;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(MultiLineVariantOverStructType) {
+    TCases cases = {
+        {"select variant<a:int32\n>",
+            "SELECT\n\tvariant<\n\t\ta: int32\n\t>;\n"},
+        {"select variant<\na:int32>",
+            "SELECT\n\tvariant<\n\t\ta: int32\n\t>;\n"},
+        {"select variant<a:int32,\n>",
+            "SELECT\n\tvariant<\n\t\ta: int32,\n\t>;\n"},
+        {"select variant<a:int32\n,>",
+            "SELECT\n\tvariant<\n\t\ta: int32,\n\t>;\n"},
+        {"select variant<\na:int32,>",
+            "SELECT\n\tvariant<\n\t\ta: int32,\n\t>;\n"},
+        {"select variant<\na:int32,b:string,\nc:double,d:bool>",
+            "SELECT\n\tvariant<\n\t\ta: int32, b: string,\n\t\tc: double, d: bool\n\t>;\n"},
+        {"select variant<\na:int32,b:string,\nc:double,d:bool,>",
+            "SELECT\n\tvariant<\n\t\ta: int32, b: string,\n\t\tc: double, d: bool,\n\t>;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(MultiLineEnum) {
+    TCases cases = {
+        {"select enum<a\n>",
+            "SELECT\n\tenum<\n\t\ta\n\t>;\n"},
+        {"select enum<\na>",
+            "SELECT\n\tenum<\n\t\ta\n\t>;\n"},
+        {"select enum<a,\n>",
+            "SELECT\n\tenum<\n\t\ta,\n\t>;\n"},
+        {"select enum<a\n,>",
+            "SELECT\n\tenum<\n\t\ta,\n\t>;\n"},
+        {"select enum<\na,>",
+            "SELECT\n\tenum<\n\t\ta,\n\t>;\n"},
+        {"select enum<\na,b,\nc,d>",
+            "SELECT\n\tenum<\n\t\ta, b,\n\t\tc, d\n\t>;\n"},
+        {"select enum<\na,b,\nc,d,>",
+            "SELECT\n\tenum<\n\t\ta, b,\n\t\tc, d,\n\t>;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(MultiLineResourceType) {
+    TCases cases = {
+        {"select resource<foo\n>",
+            "SELECT\n\tresource<\n\t\tfoo\n\t>;\n"},
+        {"select resource<\nfoo>",
+            "SELECT\n\tresource<\n\t\tfoo\n\t>;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(MultiLineTaggedType) {
+    TCases cases = {
+        {"select tagged<int32,foo\n>",
+            "SELECT\n\ttagged<\n\t\tint32, foo\n\t>;\n"},
+        {"select tagged<int32,\nfoo>",
+            "SELECT\n\ttagged<\n\t\tint32,\n\t\tfoo\n\t>;\n"},
+        {"select tagged<int32\n,foo>",
+            "SELECT\n\ttagged<\n\t\tint32,\n\t\tfoo\n\t>;\n"},
+        {"select tagged<\nint32,foo>",
+            "SELECT\n\ttagged<\n\t\tint32, foo\n\t>;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(MultiLineDictType) {
+    TCases cases = {
+        {"select dict<int32,string\n>",
+            "SELECT\n\tdict<\n\t\tint32, string\n\t>;\n"},
+        {"select dict<int32,\nstring>",
+            "SELECT\n\tdict<\n\t\tint32,\n\t\tstring\n\t>;\n"},
+        {"select dict<int32\n,string>",
+            "SELECT\n\tdict<\n\t\tint32,\n\t\tstring\n\t>;\n"},
+        {"select dict<\nint32,string>",
+            "SELECT\n\tdict<\n\t\tint32, string\n\t>;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(MultiLineCallableType) {
+    TCases cases = {
+        {"select callable<()->int32\n>",
+            "SELECT\n\tcallable<\n\t\t() -> int32\n\t>;\n"},
+        {"select callable<\n()->int32>",
+            "SELECT\n\tcallable<\n\t\t() -> int32\n\t>;\n"},
+        {"select callable<\n(int32)->int32>",
+            "SELECT\n\tcallable<\n\t\t(int32) -> int32\n\t>;\n"},
+        {"select callable<\n(int32,\ndouble)->int32>",
+            "SELECT\n\tcallable<\n\t\t(\n\t\t\tint32,\n\t\t\tdouble\n\t\t) -> int32\n\t>;\n"},
+        {"select callable<\n(int32\n,double)->int32>",
+            "SELECT\n\tcallable<\n\t\t(\n\t\t\tint32,\n\t\t\tdouble\n\t\t) -> int32\n\t>;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(UnaryOp) {
+    TCases cases = {
+        {"select -x,+x,~x,-1,-1.0,+1,+1.0,~1u",
+            "SELECT\n\t-x,\n\t+x,\n\t~x,\n\t-1,\n\t-1.0,\n\t+1,\n\t+1.0,\n\t~1u;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(MatchRecognize) {
+    TCases cases = {{R"(
+pragma FeatureR010="prototype";
+USE plato;
+SELECT
+    *
+FROM Input MATCH_RECOGNIZE(
+    PATTERN ( A )
+    DEFINE A as A
+);
+)",
+R"(PRAGMA FeatureR010 = "prototype";
+USE plato;
+
+SELECT
+    *
+FROM Input MATCH_RECOGNIZE (PATTERN (A) DEFINE A AS A);
+)"
+    }};
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(CreateTableTrailingComma) {
+    TCases cases = {
+        {"CREATE TABLE tableName (Key Uint32, PRIMARY KEY (Key),);",
+            "CREATE TABLE tableName (\n\tKey Uint32,\n\tPRIMARY KEY (Key),\n);\n"},
+        {"CREATE TABLE tableName (Key Uint32,);",
+            "CREATE TABLE tableName (\n\tKey Uint32,\n);\n"},
+    };
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(Union) {
+    TCases cases = {
+        {"select 1 union all select 2 union select 3 union all select 4 union select 5",
+            "SELECT\n\t1\nUNION ALL\nSELECT\n\t2\nUNION\nSELECT\n\t3\nUNION ALL\nSELECT\n\t4\nUNION\nSELECT\n\t5;\n"},
+            };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(CommentAfterLastSelect) {
+    TCases cases = {
+        {"SELECT 1--comment\n",
+            "SELECT\n\t1--comment\n;\n"},
+        {"SELECT 1\n\n--comment\n",
+            "SELECT\n\t1--comment\n;\n"},
+        {"SELECT 1\n\n--comment",
+            "SELECT\n\t1--comment\n;\n"},
+        {"SELECT * FROM Input\n\n\n\n/* comment */\n\n\n",
+            "SELECT\n\t*\nFROM Input/* comment */;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(WindowFunctionInsideExpr) {
+    TCases cases = {
+        {"SELECT CAST(ROW_NUMBER() OVER () AS String) AS x,\nFROM Input;",
+            "SELECT\n\tCAST(ROW_NUMBER() OVER () AS String) AS x,\nFROM Input;\n"},
+        {"SELECT CAST(ROW_NUMBER() OVER (PARTITION BY key) AS String) AS x,\nFROM Input;",
+            "SELECT\n\tCAST(\n\t\tROW_NUMBER() OVER (\n\t\t\tPARTITION BY\n\t\t\t\tkey\n\t\t) AS String\n\t) AS x,\nFROM Input;\n"},
+        {"SELECT CAST(ROW_NUMBER() OVER (users) AS String) AS x,\nFROM Input;",
+        "SELECT\n\tCAST(\n\t\tROW_NUMBER() OVER (\n\t\t\tusers\n\t\t) AS String\n\t) AS x,\nFROM Input;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(ExistsExpr) {
+    TCases cases = {
+        {"SELECT EXISTS (SELECT 1);",
+            "SELECT\n\tEXISTS (\n\t\tSELECT\n\t\t\t1\n\t);\n"},
+        {"SELECT CAST(EXISTS(SELECT 1) AS Int) AS x,\nFROM Input;",
+            "SELECT\n\tCAST(\n\t\tEXISTS (\n\t\t\tSELECT\n\t\t\t\t1\n\t\t) AS Int\n\t) AS x,\nFROM Input;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(LambdaInsideExpr) {
+    TCases cases = {
+        {"SELECT ListMap(AsList(1,2),($x)->{return $x+1});",
+            "SELECT\n\tListMap(\n\t\tAsList(1, 2), ($x) -> {\n\t\t\tRETURN $x + 1\n\t\t}\n\t);\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(CaseExpr) {
+    TCases cases = {
+        {"SELECT CASE WHEN 1 == 2 THEN 3 WHEN 4 == 5 THEN 6 WHEN 7 == 8 THEN 9 ELSE 10 END;",
+            "SELECT\n\tCASE\n\t\tWHEN 1 == 2\n\t\t\tTHEN 3\n\t\tWHEN 4 == 5\n\t\t\tTHEN 6\n\t\tWHEN 7 == 8\n\t\t\tTHEN 9\n\t\tELSE 10\n\tEND;\n"},
+        {"SELECT CAST(CASE WHEN 1 == 2 THEN 3 WHEN 4 == 5 THEN 6 ELSE 10 END AS String);",
+            "SELECT\n\tCAST(\n\t\tCASE\n\t\t\tWHEN 1 == 2\n\t\t\t\tTHEN 3\n\t\t\tWHEN 4 == 5\n\t\t\t\tTHEN 6\n\t\t\tELSE 10\n\t\tEND AS String\n\t);\n"},
+        {"SELECT CASE x WHEN 1 THEN 2 WHEN 3 THEN 4 WHEN 5 THEN 6 ELSE 10 END;",
+            "SELECT\n\tCASE x\n\t\tWHEN 1\n\t\t\tTHEN 2\n\t\tWHEN 3\n\t\t\tTHEN 4\n\t\tWHEN 5\n\t\t\tTHEN 6\n\t\tELSE 10\n\tEND;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(MultiTokenOperations) {
+    TCases cases = {
+        {"$x = 1 >>| 2;",
+            "$x = 1 >>| 2;\n"},
+            {"$x = 1 >> 2;",
+            "$x = 1 >> 2;\n"},
+            {"$x = 1 ?? 2;",
+            "$x = 1 ?? 2;\n"},
+            {"$x = 1 >  /*comment*/  >  /*comment*/  | 2;",
+            "$x = 1 >/*comment*/>/*comment*/| 2;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(OperatorNewlines) {
+    TCases cases = {
+        {"$x = TRUE\nOR\nFALSE;",
+            "$x = TRUE\n\tOR\n\tFALSE;\n"},
+        {"$x = TRUE OR\nFALSE;",
+            "$x = TRUE OR\n\tFALSE;\n"},
+        {"$x = TRUE\nOR FALSE;",
+            "$x = TRUE OR\n\tFALSE;\n"},
+        {"$x = 1\n+2\n*3;",
+            "$x = 1 +\n\t2 *\n\t\t3;\n"},
+        {"$x = 1\n+\n2\n*3\n*5\n+\n4;",
+            "$x = 1\n\t+\n\t2 *\n\t\t3 *\n\t\t5\n\t+\n\t4;\n"},
+        {"$x = 1\n+2+3+4\n+5+6+7+\n\n8+9+10;",
+            "$x = 1 +\n\t2 + 3 + 4 +\n\t5 + 6 + 7 +\n\t8 + 9 + 10;\n"},
+        {"$x = TRUE\nAND\nTRUE OR\nFALSE\nAND TRUE\nOR FALSE\nAND TRUE\nOR FALSE;",
+            "$x = TRUE\n\tAND\n\tTRUE OR\n\tFALSE AND\n\t\tTRUE OR\n\tFALSE AND\n\t\tTRUE OR\n\tFALSE;\n"},
+        {"$x = 1 -- comment\n+ 2;",
+            "$x = 1-- comment\n\t+\n\t2;\n"},
+            {"$x = 1 -- comment\n+ -- comment\n2;",
+            "$x = 1-- comment\n\t+-- comment\n\t2;\n"},
+            {"$x = 1 + -- comment\n2;",
+            "$x = 1 +-- comment\n\t2;\n"},
+            {"$x = 1\n>\n>\n|\n2;",
+            "$x = 1\n\t>>|\n\t2;\n"},
+            {"$x = 1\n?? 2 ??\n3\n??\n4 +\n5\n*\n6 +\n7 ??\n8;",
+            "$x = 1 ??\n\t2 ??\n\t3\n\t??\n\t4 +\n\t\t5\n\t\t\t*\n\t\t\t6 +\n\t\t7 ??\n\t8;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(ObfuscateSelect) {
+    TCases cases = {
+        {"select 1;",
+            "SELECT\n\t0;\n"},
+        {"select true;",
+            "SELECT\n\tFALSE;\n"},
+        {"select 'foo';",
+            "SELECT\n\t'str';\n"},
+        {"select 3.0;",
+            "SELECT\n\t0.0;\n"},
+        {"select col;",
+            "SELECT\n\tid;\n"},
+        {"select * from tab;",
+            "SELECT\n\t*\nFROM id;\n"},
+        {"select cast(col as int32);",
+            "SELECT\n\tCAST(id AS int32);\n"},
+        {"select func(col);",
+            "SELECT\n\tfunc(id);\n"},
+        {"select mod::func(col);",
+            "SELECT\n\tmod::func(id);\n"},
+        {"declare $a as int32;",
+            "DECLARE $id AS int32;\n"},
+        {"select * from `logs/of/bob` where pwd='foo';",
+            "SELECT\n\t*\nFROM id\nWHERE id = 'str';\n"},
+        {"select $f();",
+            "SELECT\n\t$id();\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases, NSQLFormat::EFormatMode::Obfuscate);
+}
+
+Y_UNIT_TEST(ObfuscatePragma) {
+    TCases cases = {
+        {"pragma a=1",
+            "PRAGMA id = 0;\n"},
+        {"pragma a='foo';",
+            "PRAGMA id = 'str';\n"},
+        {"pragma a=true;",
+            "PRAGMA id = FALSE;\n"},
+        {"pragma a=$foo;",
+            "PRAGMA id = $id;\n"},
+        {"pragma a=foo;",
+            "PRAGMA id = id;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases, NSQLFormat::EFormatMode::Obfuscate);
+}
+
+Y_UNIT_TEST(CreateView) {
+    TCases cases = {
+        {"creAte vIEw TheView wiTh (security_invoker = trUE) As SELect 1",
+            "CREATE VIEW TheView WITH (security_invoker = TRUE) AS\nSELECT\n\t1;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(DropView) {
+    TCases cases = {
+        {"dRop viEW theVIEW",
+            "DROP VIEW theVIEW;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(ResourcePoolOperations) {
+    TCases cases = {
+        {"creAte reSourCe poOl naMe With (a = \"b\")",
+            "CREATE RESOURCE POOL naMe WITH (a = \"b\");\n"},
+            {"create resource pool eds with (a=\"a\",b=\"b\",c = true)",
+            "CREATE RESOURCE POOL eds WITH (\n\ta = \"a\",\n\tb = \"b\",\n\tc = TRUE\n);\n"},
+            {"alTer reSOurcE poOl naMe resEt (b, c), seT (x=y, z=false)",
+            "ALTER RESOURCE POOL naMe\n\tRESET (b, c),\n\tSET (x = y, z = FALSE);\n"},
+            {"alter resource pool eds reset (a), set (x=y)",
+            "ALTER RESOURCE POOL eds\n\tRESET (a),\n\tSET (x = y);\n"},
+        {"dRop reSourCe poOl naMe",
+            "DROP RESOURCE POOL naMe;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(BackupCollectionOperations) {
+    TCases cases = {
+        {"creAte  BackuP colLection `-naMe` wIth (a = \"b\")",
+            "CREATE BACKUP COLLECTION `-naMe` WITH (a = \"b\");\n"},
+            {"alTer bACKuP coLLECTION naMe resEt (b, c), seT (x=y, z=false)",
+            "ALTER BACKUP COLLECTION naMe\n\tRESET (b, c),\n\tSET (x = y, z = FALSE);\n"},
+        {"DROP backup collectiOn       `/some/path`",
+            "DROP BACKUP COLLECTION `/some/path`;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(Analyze) {
+    TCases cases = {
+        {"analyze table (col1, col2, col3)",
+            "ANALYZE table (col1, col2, col3);\n"},
+            {"analyze table",
+            "ANALYZE table;\n"}
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
+
+Y_UNIT_TEST(ResourcePoolClassifierOperations) {
+    TCases cases = {
+        {"creAte reSourCe poOl ClaSsiFIer naMe With (a = \"b\")",
+            "CREATE RESOURCE POOL CLASSIFIER naMe WITH (a = \"b\");\n"},
+            {"create resource pool classifier eds with (a=\"a\",b=\"b\",c = true)",
+            "CREATE RESOURCE POOL CLASSIFIER eds WITH (\n\ta = \"a\",\n\tb = \"b\",\n\tc = TRUE\n);\n"},
+            {"alTer reSOurcE poOl ClaSsiFIer naMe resEt (b, c), seT (x=y, z=false)",
+            "ALTER RESOURCE POOL CLASSIFIER naMe\n\tRESET (b, c),\n\tSET (x = y, z = FALSE);\n"},
+            {"alter resource pool classifier eds reset (a), set (x=y)",
+            "ALTER RESOURCE POOL CLASSIFIER eds\n\tRESET (a),\n\tSET (x = y);\n"},
+        {"dRop reSourCe poOl ClaSsiFIer naMe",
+            "DROP RESOURCE POOL CLASSIFIER naMe;\n"},
+    };
+
+    TSetup setup;
+    setup.Run(cases);
+}
\ No newline at end of file
diff --git a/ydb/library/yql/sql/v1/format/sql_format_ut_antlr4.cpp b/ydb/library/yql/sql/v1/format/sql_format_ut_antlr4.cpp
new file mode 100644
index 000000000000..63c08bb8b7ef
--- /dev/null
+++ b/ydb/library/yql/sql/v1/format/sql_format_ut_antlr4.cpp
@@ -0,0 +1,52 @@
+#include <library/cpp/testing/unittest/registar.h>
+
+#include "sql_format.h"
+
+#include <google/protobuf/arena.h>
+#include <util/string/subst.h>
+#include <util/string/join.h>
+
+namespace {
+
+using TCases = TVector<std::pair<TString, TString>>;
+
+struct TSetup {
+    TSetup() {
+        NSQLTranslation::TTranslationSettings settings;
+        settings.Arena = &Arena;
+        settings.Antlr4Parser = true;
+        Formatter = NSQLFormat::MakeSqlFormatter(settings);
+    }
+    
+    void Run(const TCases& cases, NSQLFormat::EFormatMode mode = NSQLFormat::EFormatMode::Pretty) {
+        for (const auto& c : cases) {
+            NYql::TIssues issues;
+            TString formatted;
+            auto res = Formatter->Format(c.first, formatted, issues, mode);
+            UNIT_ASSERT_C(res, issues.ToString());
+            auto expected = c.second;
+            SubstGlobal(expected, "\t", TString(NSQLFormat::OneIndent, ' '));
+            UNIT_ASSERT_NO_DIFF(formatted, expected);
+
+            TString formatted2;
+            auto res2 = Formatter->Format(formatted, formatted2, issues);
+            UNIT_ASSERT_C(res2, issues.ToString());
+            UNIT_ASSERT_NO_DIFF(formatted, formatted2);
+
+            if (mode == NSQLFormat::EFormatMode::Pretty) {
+                auto mutatedQuery = NSQLFormat::MutateQuery(c.first);
+                auto res3 = Formatter->Format(mutatedQuery, formatted, issues);
+                UNIT_ASSERT_C(res3, issues.ToString());
+            }
+        }
+    }
+
+    google::protobuf::Arena Arena;
+    NSQLFormat::ISqlFormatter::TPtr Formatter;
+};
+
+}
+
+Y_UNIT_TEST_SUITE(CheckSqlFormatter) {
+    #include "sql_format_ut.h"
+}
diff --git a/ydb/library/yql/sql/v1/format/ut_antlr4/ya.make b/ydb/library/yql/sql/v1/format/ut_antlr4/ya.make
new file mode 100644
index 000000000000..d9ce6b9939de
--- /dev/null
+++ b/ydb/library/yql/sql/v1/format/ut_antlr4/ya.make
@@ -0,0 +1,7 @@
+UNITTEST_FOR(ydb/library/yql/sql/v1/format)
+
+SRCS(
+    sql_format_ut_antlr4.cpp
+)
+
+END()
diff --git a/ydb/library/yql/sql/v1/format/ya.make b/ydb/library/yql/sql/v1/format/ya.make
index 6d49f16e9458..8dfeae18b883 100644
--- a/ydb/library/yql/sql/v1/format/ya.make
+++ b/ydb/library/yql/sql/v1/format/ya.make
@@ -6,6 +6,7 @@ SRCS(
 )
 
 RESOURCE(DONT_PARSE ../SQLv1.g.in SQLv1.g.in)
+RESOURCE(DONT_PARSE ../SQLv1Antlr4.g.in SQLv1Antlr4.g.in)
 
 PEERDIR(
     ydb/library/yql/parser/lexer_common
@@ -21,4 +22,5 @@ END()
 
 RECURSE_FOR_TESTS(
     ut
+    ut_antlr4
 )
diff --git a/ydb/library/yql/sql/v1/lexer/lexer.cpp b/ydb/library/yql/sql/v1/lexer/lexer.cpp
index 9f82c77b0b4a..f117bcd0f84b 100644
--- a/ydb/library/yql/sql/v1/lexer/lexer.cpp
+++ b/ydb/library/yql/sql/v1/lexer/lexer.cpp
@@ -4,6 +4,8 @@
 #include <ydb/library/yql/parser/proto_ast/collect_issues/collect_issues.h>
 #include <ydb/library/yql/parser/proto_ast/gen/v1/SQLv1Lexer.h>
 #include <ydb/library/yql/parser/proto_ast/gen/v1_ansi/SQLv1Lexer.h>
+#include <ydb/library/yql/parser/proto_ast/gen/v1_antlr4/SQLv1Antlr4Lexer.h>
+#include <ydb/library/yql/parser/proto_ast/gen/v1_ansi_antlr4/SQLv1Antlr4Lexer.h>
 
 #if defined(_tsan_enabled_)
 #include <util/system/mutex.h>
@@ -17,6 +19,7 @@ namespace NALPAnsi {
 extern ANTLR_UINT8 *SQLv1ParserTokenNames[];
 }
 
+
 namespace NSQLTranslationV1 {
 
 namespace {
@@ -29,8 +32,8 @@ using NSQLTranslation::ILexer;
 
 class TV1Lexer : public ILexer {
 public:
-    explicit TV1Lexer(bool ansi)
-        : Ansi(ansi)
+    explicit TV1Lexer(bool ansi, bool antlr4)
+        : Ansi(ansi), Antlr4(antlr4)
     {
     }
 
@@ -40,12 +43,18 @@ class TV1Lexer : public ILexer {
         TGuard<TMutex> grd(SanitizerSQLTranslationMutex);
 #endif
         NSQLTranslation::TErrorCollectorOverIssues collector(newIssues, maxErrors, "");
-        if (Ansi) {
+        if (Ansi && !Antlr4) {
             NProtoAST::TLexerTokensCollector<NALPAnsi::SQLv1Lexer> tokensCollector(query, (const char**)NALPAnsi::SQLv1ParserTokenNames, queryName);
             tokensCollector.CollectTokens(collector, onNextToken);
-        } else {
+        } else if (!Ansi && !Antlr4) {
             NProtoAST::TLexerTokensCollector<NALPDefault::SQLv1Lexer> tokensCollector(query, (const char**)NALPDefault::SQLv1ParserTokenNames, queryName);
             tokensCollector.CollectTokens(collector, onNextToken);
+        } else if (Ansi && Antlr4) {
+            NProtoAST::TLexerTokensCollector<NALPAnsiAntlr4::SQLv1Antlr4Lexer> tokensCollector(query, queryName);
+            tokensCollector.CollectTokens(collector, onNextToken);
+        } else {
+            NProtoAST::TLexerTokensCollector<NALPDefaultAntlr4::SQLv1Antlr4Lexer> tokensCollector(query, queryName);
+            tokensCollector.CollectTokens(collector, onNextToken);
         }
 
         issues.AddIssues(newIssues);
@@ -54,12 +63,13 @@ class TV1Lexer : public ILexer {
 
 private:
     const bool Ansi;
+    const bool Antlr4;
 };
 
 } // namespace
 
-NSQLTranslation::ILexer::TPtr MakeLexer(bool ansi) {
-    return NSQLTranslation::ILexer::TPtr(new TV1Lexer(ansi));
+NSQLTranslation::ILexer::TPtr MakeLexer(bool ansi, bool antlr4) {
+    return NSQLTranslation::ILexer::TPtr(new TV1Lexer(ansi, antlr4));
 }
 
 } //  namespace NSQLTranslationV1
diff --git a/ydb/library/yql/sql/v1/lexer/lexer.h b/ydb/library/yql/sql/v1/lexer/lexer.h
index 312c1e207247..f71ad750d82d 100644
--- a/ydb/library/yql/sql/v1/lexer/lexer.h
+++ b/ydb/library/yql/sql/v1/lexer/lexer.h
@@ -4,6 +4,6 @@
 
 namespace NSQLTranslationV1 {
 
-NSQLTranslation::ILexer::TPtr MakeLexer(bool ansi);
+NSQLTranslation::ILexer::TPtr MakeLexer(bool ansi, bool antlr4);
 
 }
diff --git a/ydb/library/yql/sql/v1/lexer/ya.make b/ydb/library/yql/sql/v1/lexer/ya.make
index 01a200311c3b..9d140dd41d87 100644
--- a/ydb/library/yql/sql/v1/lexer/ya.make
+++ b/ydb/library/yql/sql/v1/lexer/ya.make
@@ -6,6 +6,8 @@ PEERDIR(
     ydb/library/yql/parser/proto_ast/gen/v1
     ydb/library/yql/parser/proto_ast/gen/v1_ansi
     ydb/library/yql/parser/proto_ast/gen/v1_proto_split
+    ydb/library/yql/parser/proto_ast/gen/v1_antlr4
+    ydb/library/yql/parser/proto_ast/gen/v1_ansi_antlr4
 )
 
 SRCS(
diff --git a/ydb/library/yql/sql/v1/proto_parser/proto_parser.cpp b/ydb/library/yql/sql/v1/proto_parser/proto_parser.cpp
index 04334f50b960..e07305e66889 100644
--- a/ydb/library/yql/sql/v1/proto_parser/proto_parser.cpp
+++ b/ydb/library/yql/sql/v1/proto_parser/proto_parser.cpp
@@ -7,6 +7,10 @@
 #include <ydb/library/yql/parser/proto_ast/gen/v1/SQLv1Parser.h>
 #include <ydb/library/yql/parser/proto_ast/gen/v1_ansi/SQLv1Lexer.h>
 #include <ydb/library/yql/parser/proto_ast/gen/v1_ansi/SQLv1Parser.h>
+#include <ydb/library/yql/parser/proto_ast/gen/v1_antlr4/SQLv1Antlr4Lexer.h>
+#include <ydb/library/yql/parser/proto_ast/gen/v1_antlr4/SQLv1Antlr4Parser.h>
+#include <ydb/library/yql/parser/proto_ast/gen/v1_ansi_antlr4/SQLv1Antlr4Lexer.h>
+#include <ydb/library/yql/parser/proto_ast/gen/v1_ansi_antlr4/SQLv1Antlr4Parser.h>
 
 #include <ydb/library/yql/parser/proto_ast/gen/v1_proto_split/SQLv1Parser.pb.main.h>
 
@@ -18,7 +22,6 @@ using namespace NYql;
 
 namespace NSQLTranslationV1 {
 
-using NALPDefault::SQLv1LexerTokens;
 
 #if defined(_tsan_enabled_)
     TMutex SanitizerSQLTranslationMutex;
@@ -26,32 +29,44 @@ using NALPDefault::SQLv1LexerTokens;
 
 using namespace NSQLv1Generated;
 
-google::protobuf::Message* SqlAST(const TString& query, const TString& queryName, TIssues& err, size_t maxErrors, bool ansiLexer, google::protobuf::Arena* arena) {
+google::protobuf::Message* SqlAST(const TString& query, const TString& queryName, TIssues& err, size_t maxErrors, bool ansiLexer, bool anlr4Parser, google::protobuf::Arena* arena) {
     YQL_ENSURE(arena);
 #if defined(_tsan_enabled_)
     TGuard<TMutex> grd(SanitizerSQLTranslationMutex);
 #endif
     NSQLTranslation::TErrorCollectorOverIssues collector(err, maxErrors, "");
-    if (ansiLexer) {
+    if (ansiLexer && !anlr4Parser) {
         NProtoAST::TProtoASTBuilder<NALPAnsi::SQLv1Parser, NALPAnsi::SQLv1Lexer> builder(query, queryName, arena);
         return builder.BuildAST(collector);
-    } else {
+    } else if (!ansiLexer && !anlr4Parser) {
         NProtoAST::TProtoASTBuilder<NALPDefault::SQLv1Parser, NALPDefault::SQLv1Lexer> builder(query, queryName, arena);
         return builder.BuildAST(collector);
+    } else if (ansiLexer && anlr4Parser) {
+        NProtoAST::TProtoASTBuilder<NALPAnsiAntlr4::SQLv1Antlr4Parser, NALPAnsiAntlr4::SQLv1Antlr4Lexer> builder(query, queryName, arena);
+        return builder.BuildAST(collector);
+    } else {
+        NProtoAST::TProtoASTBuilder<NALPDefaultAntlr4::SQLv1Antlr4Parser, NALPDefaultAntlr4::SQLv1Antlr4Lexer> builder(query, queryName, arena);
+        return builder.BuildAST(collector);
     }
 }
 
-google::protobuf::Message* SqlAST(const TString& query, const TString& queryName, NProtoAST::IErrorCollector& err, bool ansiLexer, google::protobuf::Arena* arena) {
+google::protobuf::Message* SqlAST(const TString& query, const TString& queryName, NProtoAST::IErrorCollector& err, bool ansiLexer, bool anlr4Parser, google::protobuf::Arena* arena) {
     YQL_ENSURE(arena);
 #if defined(_tsan_enabled_)
     TGuard<TMutex> grd(SanitizerSQLTranslationMutex);
 #endif
-    if (ansiLexer) {
+    if (ansiLexer && !anlr4Parser) {
         NProtoAST::TProtoASTBuilder<NALPAnsi::SQLv1Parser, NALPAnsi::SQLv1Lexer> builder(query, queryName, arena);
         return builder.BuildAST(err);
-    } else {
+    } else if (!ansiLexer && !anlr4Parser) {
         NProtoAST::TProtoASTBuilder<NALPDefault::SQLv1Parser, NALPDefault::SQLv1Lexer> builder(query, queryName, arena);
         return builder.BuildAST(err);
+    } else if (ansiLexer && anlr4Parser) {
+        NProtoAST::TProtoASTBuilder<NALPAnsiAntlr4::SQLv1Antlr4Parser, NALPAnsiAntlr4::SQLv1Antlr4Lexer> builder(query, queryName, arena);
+        return builder.BuildAST(err);
+    } else {
+        NProtoAST::TProtoASTBuilder<NALPDefaultAntlr4::SQLv1Antlr4Parser, NALPDefaultAntlr4::SQLv1Antlr4Lexer> builder(query, queryName, arena);
+        return builder.BuildAST(err);
     }
 }
 
diff --git a/ydb/library/yql/sql/v1/proto_parser/proto_parser.h b/ydb/library/yql/sql/v1/proto_parser/proto_parser.h
index 64ea34b00600..0c629f6fce6c 100644
--- a/ydb/library/yql/sql/v1/proto_parser/proto_parser.h
+++ b/ydb/library/yql/sql/v1/proto_parser/proto_parser.h
@@ -14,7 +14,7 @@ namespace NSQLTranslation {
 
 namespace NSQLTranslationV1 {
 
-    google::protobuf::Message* SqlAST(const TString& query, const TString& queryName, NYql::TIssues& err, size_t maxErrors, bool ansiLexer, google::protobuf::Arena* arena = nullptr);
-    google::protobuf::Message* SqlAST(const TString& query, const TString& queryName, NProtoAST::IErrorCollector& err, bool ansiLexer, google::protobuf::Arena* arena);
+    google::protobuf::Message* SqlAST(const TString& query, const TString& queryName, NYql::TIssues& err, size_t maxErrors, bool ansiLexer, bool antlr4Parser, google::protobuf::Arena* arena = nullptr);
+    google::protobuf::Message* SqlAST(const TString& query, const TString& queryName, NProtoAST::IErrorCollector& err, bool ansiLexer, bool antlr4Parser, google::protobuf::Arena* arena);
 
 }  // namespace NSQLTranslationV1
diff --git a/ydb/library/yql/sql/v1/proto_parser/ya.make b/ydb/library/yql/sql/v1/proto_parser/ya.make
index 5c16e92fa0cd..2c2856f9d49e 100644
--- a/ydb/library/yql/sql/v1/proto_parser/ya.make
+++ b/ydb/library/yql/sql/v1/proto_parser/ya.make
@@ -8,6 +8,8 @@ PEERDIR(
     ydb/library/yql/parser/proto_ast/gen/v1
     ydb/library/yql/parser/proto_ast/gen/v1_ansi
     ydb/library/yql/parser/proto_ast/gen/v1_proto_split
+    ydb/library/yql/parser/proto_ast/gen/v1_antlr4
+    ydb/library/yql/parser/proto_ast/gen/v1_ansi_antlr4
 )
 
 SRCS(
diff --git a/ydb/library/yql/sql/v1/sql.cpp b/ydb/library/yql/sql/v1/sql.cpp
index b46440697508..ca1534ffd182 100644
--- a/ydb/library/yql/sql/v1/sql.cpp
+++ b/ydb/library/yql/sql/v1/sql.cpp
@@ -93,7 +93,7 @@ NYql::TAstParseResult SqlToYql(const TString& query, const NSQLTranslation::TTra
     const TString queryName = "query";
 
     NSQLTranslation::TSQLHints hints;
-    auto lexer = MakeLexer(settings.AnsiLexer);
+    auto lexer = MakeLexer(settings.AnsiLexer, settings.Antlr4Parser);
     YQL_ENSURE(lexer);
     if (!CollectSqlHints(*lexer, query, queryName, settings.File, hints, res.Issues, settings.MaxErrors)) {
         return res;
@@ -102,7 +102,7 @@ NYql::TAstParseResult SqlToYql(const TString& query, const NSQLTranslation::TTra
     TContext ctx(settings, hints, res.Issues);
     NSQLTranslation::TErrorCollectorOverIssues collector(res.Issues, settings.MaxErrors, settings.File);
 
-    google::protobuf::Message* ast(SqlAST(query, queryName, collector, settings.AnsiLexer, settings.Arena));
+    google::protobuf::Message* ast(SqlAST(query, queryName, collector, settings.AnsiLexer,  settings.Antlr4Parser, settings.Arena));
     if (ast) {
         SqlASTToYqlImpl(res, *ast, ctx);
     } else {
@@ -186,7 +186,7 @@ TVector<NYql::TAstParseResult> SqlToAstStatements(const TString& query, const NS
     TIssues issues;
 
     NSQLTranslation::TSQLHints hints;
-    auto lexer = MakeLexer(settings.AnsiLexer);
+    auto lexer = MakeLexer(settings.AnsiLexer, settings.Antlr4Parser);
     YQL_ENSURE(lexer);
     if (!CollectSqlHints(*lexer, query, queryName, settings.File, hints, issues, settings.MaxErrors)) {
         return result;
@@ -195,7 +195,7 @@ TVector<NYql::TAstParseResult> SqlToAstStatements(const TString& query, const NS
     TContext ctx(settings, hints, issues);
     NSQLTranslation::TErrorCollectorOverIssues collector(issues, settings.MaxErrors, settings.File);
 
-    google::protobuf::Message* astProto(SqlAST(query, queryName, collector, settings.AnsiLexer, settings.Arena));
+    google::protobuf::Message* astProto(SqlAST(query, queryName, collector, settings.AnsiLexer, settings.Antlr4Parser, settings.Arena));
     if (astProto) {
         auto ast = static_cast<const TSQLv1ParserAST&>(*astProto);
         const auto& query = ast.GetRule_sql_query();
diff --git a/ydb/library/yql/sql/v1/sql_expression.cpp b/ydb/library/yql/sql/v1/sql_expression.cpp
index ddf1b4ca54ed..057e182580c8 100644
--- a/ydb/library/yql/sql/v1/sql_expression.cpp
+++ b/ydb/library/yql/sql/v1/sql_expression.cpp
@@ -3,6 +3,7 @@
 #include "sql_select.h"
 #include "sql_values.h"
 #include <ydb/library/yql/parser/proto_ast/gen/v1/SQLv1Lexer.h>
+#include <ydb/library/yql/parser/proto_ast/gen/v1_antlr4/SQLv1Antlr4Lexer.h>
 #include <ydb/library/yql/utils/utf8.h>
 #include <util/charset/wide.h>
 #include <util/string/ascii.h>
@@ -11,6 +12,7 @@
 namespace NSQLTranslationV1 {
 
 using NALPDefault::SQLv1LexerTokens;
+using NALPDefaultAntlr4::SQLv1Antlr4Lexer;
 
 using namespace NSQLv1Generated;
 
@@ -1632,15 +1634,19 @@ TNodePtr TSqlExpression::SubExpr(const TRule_con_subexpr& node, const TTrailingQ
             auto token = node.GetAlt_con_subexpr2().GetRule_unary_op1().GetToken1();
             Token(token);
             TPosition pos(Ctx.Pos());
-            switch (token.GetId()) {
-                case SQLv1LexerTokens::TOKEN_NOT: opName = "Not"; break;
-                case SQLv1LexerTokens::TOKEN_PLUS: opName = "Plus"; break;
-                case SQLv1LexerTokens::TOKEN_MINUS: opName = Ctx.Scoped->PragmaCheckedOps ? "CheckedMinus" : "Minus"; break;
-                case SQLv1LexerTokens::TOKEN_TILDA: opName = "BitNot"; break;
-                default:
-                    Ctx.IncrementMonCounter("sql_errors", "UnsupportedUnaryOperation");
-                    Error() << "Unsupported unary operation: " << token.GetValue();
-                    return nullptr;
+            auto tokenId = token.GetId();
+            if (IS_TOKEN(tokenId, NOT)) {
+                opName = "Not";
+            } else if (IS_TOKEN(tokenId, PLUS)) {
+                opName = "Plus";
+            } else if (IS_TOKEN(tokenId, MINUS)) {
+                opName = Ctx.Scoped->PragmaCheckedOps ? "CheckedMinus" : "Minus";
+            } else if (IS_TOKEN(tokenId, TILDA)) {
+                opName = "BitNot";
+            } else {
+                Ctx.IncrementMonCounter("sql_errors", "UnsupportedUnaryOperation");
+                Error() << "Unsupported unary operation: " << token.GetValue();
+                return nullptr;
             }
             Ctx.IncrementMonCounter("sql_unary_operations", opName);
             auto expr = UnaryExpr(node.GetAlt_con_subexpr2().GetRule_unary_subexpr2(), tail);
@@ -1907,7 +1913,7 @@ TNodePtr TSqlExpression::SubExpr(const TRule_xor_subexpr& node, const TTrailingQ
             }
             case TRule_cond_expr::kAltCondExpr4: {
                 auto alt = cond.GetAlt_cond_expr4();
-                const bool symmetric = alt.HasBlock3() && alt.GetBlock3().GetToken1().GetId() == SQLv1LexerTokens::TOKEN_SYMMETRIC;
+                const bool symmetric = alt.HasBlock3() && IS_TOKEN(alt.GetBlock3().GetToken1().GetId(), SYMMETRIC);
                 const bool negation = alt.HasBlock1();
                 TNodePtr left = SubExpr(alt.GetRule_eq_subexpr4(), {});
                 TNodePtr right = SubExpr(alt.GetRule_eq_subexpr6(), tail);
@@ -2033,52 +2039,42 @@ TNodePtr TSqlExpression::BinOpList(const TNode& node, TGetNode getNode, TIter be
         TPosition pos(Ctx.Pos());
         TString opName;
         auto tokenId = begin->GetToken1().GetId();
-        switch (tokenId) {
-            case SQLv1LexerTokens::TOKEN_LESS:
-                Ctx.IncrementMonCounter("sql_binary_operations", "Less");
-                opName = "<";
-                break;
-            case SQLv1LexerTokens::TOKEN_LESS_OR_EQ:
-                opName = "<=";
-                Ctx.IncrementMonCounter("sql_binary_operations", "LessOrEq");
-                break;
-            case SQLv1LexerTokens::TOKEN_GREATER:
-                opName = ">";
-                Ctx.IncrementMonCounter("sql_binary_operations", "Greater");
-                break;
-            case SQLv1LexerTokens::TOKEN_GREATER_OR_EQ:
-                opName = ">=";
-                Ctx.IncrementMonCounter("sql_binary_operations", "GreaterOrEq");
-                break;
-            case SQLv1LexerTokens::TOKEN_PLUS:
-                opName = Ctx.Scoped->PragmaCheckedOps ? "CheckedAdd" : "+MayWarn";
-                Ctx.IncrementMonCounter("sql_binary_operations", "Plus");
-                break;
-            case SQLv1LexerTokens::TOKEN_MINUS:
-                opName = Ctx.Scoped->PragmaCheckedOps ? "CheckedSub" : "-MayWarn";
-                Ctx.IncrementMonCounter("sql_binary_operations", "Minus");
-                break;
-            case SQLv1LexerTokens::TOKEN_ASTERISK:
-                opName = Ctx.Scoped->PragmaCheckedOps ? "CheckedMul" : "*MayWarn";
-                Ctx.IncrementMonCounter("sql_binary_operations", "Multiply");
-                break;
-            case SQLv1LexerTokens::TOKEN_SLASH:
-                opName = "/MayWarn";
-                Ctx.IncrementMonCounter("sql_binary_operations", "Divide");
-                if (!Ctx.Scoped->PragmaClassicDivision && partialResult) {
-                    partialResult = new TCallNodeImpl(pos, "SafeCast", {std::move(partialResult), BuildDataType(pos, "Double")});
-                } else if (Ctx.Scoped->PragmaCheckedOps) {
-                    opName = "CheckedDiv";
-                }
-                break;
-            case SQLv1LexerTokens::TOKEN_PERCENT:
-                opName = Ctx.Scoped->PragmaCheckedOps ? "CheckedMod" : "%MayWarn";
-                Ctx.IncrementMonCounter("sql_binary_operations", "Mod");
-                break;
-            default:
-                Ctx.IncrementMonCounter("sql_errors", "UnsupportedBinaryOperation");
-                Error() << "Unsupported binary operation token: " << tokenId;
-                return nullptr;
+        if (IS_TOKEN(tokenId, LESS)) {
+            opName = "<";
+            Ctx.IncrementMonCounter("sql_binary_operations", "Less");
+        } else if (IS_TOKEN(tokenId, LESS_OR_EQ)) {
+            opName = "<=";
+            Ctx.IncrementMonCounter("sql_binary_operations", "LessOrEq");
+        } else if (IS_TOKEN(tokenId, GREATER)) {
+            opName = ">";
+            Ctx.IncrementMonCounter("sql_binary_operations", "Greater");
+        } else if (IS_TOKEN(tokenId, GREATER_OR_EQ)) {
+            opName = ">=";
+            Ctx.IncrementMonCounter("sql_binary_operations", "GreaterOrEq");
+        } else if (IS_TOKEN(tokenId, PLUS)) {
+            opName = Ctx.Scoped->PragmaCheckedOps ? "CheckedAdd" : "+MayWarn";
+            Ctx.IncrementMonCounter("sql_binary_operations", "Plus");
+        } else if (IS_TOKEN(tokenId, MINUS)) {
+            opName = Ctx.Scoped->PragmaCheckedOps ? "CheckedSub" : "-MayWarn";
+            Ctx.IncrementMonCounter("sql_binary_operations", "Minus");
+        } else if (IS_TOKEN(tokenId, ASTERISK)) {
+            opName = Ctx.Scoped->PragmaCheckedOps ? "CheckedMul" : "*MayWarn";
+            Ctx.IncrementMonCounter("sql_binary_operations", "Multiply");
+        } else if (IS_TOKEN(tokenId, SLASH)) {
+            opName = "/MayWarn";
+            Ctx.IncrementMonCounter("sql_binary_operations", "Divide");
+            if (!Ctx.Scoped->PragmaClassicDivision && partialResult) {
+                partialResult = new TCallNodeImpl(pos, "SafeCast", {std::move(partialResult), BuildDataType(pos, "Double")});
+            } else if (Ctx.Scoped->PragmaCheckedOps) {
+                opName = "CheckedDiv";
+            }
+        } else if (IS_TOKEN(tokenId, PERCENT)) {
+            opName = Ctx.Scoped->PragmaCheckedOps ? "CheckedMod" : "%MayWarn";
+            Ctx.IncrementMonCounter("sql_binary_operations", "Mod");
+        } else {
+            Ctx.IncrementMonCounter("sql_errors", "UnsupportedBinaryOperation");
+            Error() << "Unsupported binary operation token: " << tokenId;
+            return nullptr;
         }
 
         partialResult = BuildBinaryOp(Ctx, pos, opName, partialResult, SubExpr(getNode(*begin), (begin + 1 == end) ? tail : TTrailingQuestions{}));
@@ -2099,7 +2095,7 @@ TNodePtr TSqlExpression::BinOpList(const TRule_bit_subexpr& node, TGetNode getNo
             case TRule_neq_subexpr_TBlock2_TBlock1::kAlt1: {
                 Token(begin->GetBlock1().GetAlt1().GetToken1());
                 auto tokenId = begin->GetBlock1().GetAlt1().GetToken1().GetId();
-                if (tokenId != SQLv1LexerTokens::TOKEN_SHIFT_LEFT) {
+                if (!IS_TOKEN(tokenId, SHIFT_LEFT)) {
                     Error() << "Unsupported binary operation token: " << tokenId;
                     return {};
                 }
@@ -2115,7 +2111,7 @@ TNodePtr TSqlExpression::BinOpList(const TRule_bit_subexpr& node, TGetNode getNo
             case TRule_neq_subexpr_TBlock2_TBlock1::kAlt3: {
                 Token(begin->GetBlock1().GetAlt3().GetToken1());
                 auto tokenId = begin->GetBlock1().GetAlt3().GetToken1().GetId();
-                if (tokenId != SQLv1LexerTokens::TOKEN_ROT_LEFT) {
+                if (!IS_TOKEN(tokenId, ROT_LEFT)) {
                     Error() << "Unsupported binary operation token: " << tokenId;
                     return {};
                 }
@@ -2131,7 +2127,7 @@ TNodePtr TSqlExpression::BinOpList(const TRule_bit_subexpr& node, TGetNode getNo
             case TRule_neq_subexpr_TBlock2_TBlock1::kAlt5: {
                 Token(begin->GetBlock1().GetAlt5().GetToken1());
                 auto tokenId = begin->GetBlock1().GetAlt5().GetToken1().GetId();
-                if (tokenId != SQLv1LexerTokens::TOKEN_AMPERSAND) {
+                if (!IS_TOKEN(tokenId, AMPERSAND)) {
                     Error() << "Unsupported binary operation token: " << tokenId;
                     return {};
                 }
@@ -2142,7 +2138,7 @@ TNodePtr TSqlExpression::BinOpList(const TRule_bit_subexpr& node, TGetNode getNo
             case TRule_neq_subexpr_TBlock2_TBlock1::kAlt6: {
                 Token(begin->GetBlock1().GetAlt6().GetToken1());
                 auto tokenId = begin->GetBlock1().GetAlt6().GetToken1().GetId();
-                if (tokenId != SQLv1LexerTokens::TOKEN_PIPE) {
+                if (!IS_TOKEN(tokenId, PIPE)) {
                     Error() << "Unsupported binary operation token: " << tokenId;
                     return {};
                 }
@@ -2153,7 +2149,7 @@ TNodePtr TSqlExpression::BinOpList(const TRule_bit_subexpr& node, TGetNode getNo
             case TRule_neq_subexpr_TBlock2_TBlock1::kAlt7: {
                 Token(begin->GetBlock1().GetAlt7().GetToken1());
                 auto tokenId = begin->GetBlock1().GetAlt7().GetToken1().GetId();
-                if (tokenId != SQLv1LexerTokens::TOKEN_CARET) {
+                if (!IS_TOKEN(tokenId, CARET)) {
                     Error() << "Unsupported binary operation token: " << tokenId;
                     return {};
                 }
@@ -2183,7 +2179,7 @@ TNodePtr TSqlExpression::BinOpList(const TRule_eq_subexpr& node, TGetNode getNod
             case TRule_cond_expr::TAlt5::TBlock1::TBlock1::kAlt1: {
                 Token(begin->GetBlock1().GetAlt1().GetToken1());
                 auto tokenId = begin->GetBlock1().GetAlt1().GetToken1().GetId();
-                if (tokenId != SQLv1LexerTokens::TOKEN_EQUALS) {
+                if (!IS_TOKEN(tokenId, EQUALS)) {
                     Error() << "Unsupported binary operation token: " << tokenId;
                     return {};
                 }
@@ -2194,7 +2190,7 @@ TNodePtr TSqlExpression::BinOpList(const TRule_eq_subexpr& node, TGetNode getNod
             case TRule_cond_expr::TAlt5::TBlock1::TBlock1::kAlt2: {
                 Token(begin->GetBlock1().GetAlt2().GetToken1());
                 auto tokenId = begin->GetBlock1().GetAlt2().GetToken1().GetId();
-                if (tokenId != SQLv1LexerTokens::TOKEN_EQUALS2) {
+                if (!IS_TOKEN(tokenId, EQUALS2)) {
                     Error() << "Unsupported binary operation token: " << tokenId;
                     return {};
                 }
@@ -2205,7 +2201,7 @@ TNodePtr TSqlExpression::BinOpList(const TRule_eq_subexpr& node, TGetNode getNod
             case TRule_cond_expr::TAlt5::TBlock1::TBlock1::kAlt3: {
                 Token(begin->GetBlock1().GetAlt3().GetToken1());
                 auto tokenId = begin->GetBlock1().GetAlt3().GetToken1().GetId();
-                if (tokenId != SQLv1LexerTokens::TOKEN_NOT_EQUALS) {
+                if (!IS_TOKEN(tokenId, NOT_EQUALS)) {
                     Error() << "Unsupported binary operation token: " << tokenId;
                     return {};
                 }
@@ -2216,7 +2212,7 @@ TNodePtr TSqlExpression::BinOpList(const TRule_eq_subexpr& node, TGetNode getNod
             case TRule_cond_expr::TAlt5::TBlock1::TBlock1::kAlt4: {
                 Token(begin->GetBlock1().GetAlt4().GetToken1());
                 auto tokenId = begin->GetBlock1().GetAlt4().GetToken1().GetId();
-                if (tokenId != SQLv1LexerTokens::TOKEN_NOT_EQUALS2) {
+                if (!IS_TOKEN(tokenId, NOT_EQUALS2)) {
                     Error() << "Unsupported binary operation token: " << tokenId;
                     return {};
                 }
diff --git a/ydb/library/yql/sql/v1/sql_query.cpp b/ydb/library/yql/sql/v1/sql_query.cpp
index 066672b7c5c8..8733b165b187 100644
--- a/ydb/library/yql/sql/v1/sql_query.cpp
+++ b/ydb/library/yql/sql/v1/sql_query.cpp
@@ -5,6 +5,7 @@
 #include "sql_values.h"
 #include "node.h"
 #include <ydb/library/yql/parser/proto_ast/gen/v1/SQLv1Lexer.h>
+#include <ydb/library/yql/parser/proto_ast/gen/v1_antlr4/SQLv1Antlr4Lexer.h>
 #include <ydb/library/yql/sql/v1/object_processing.h>
 #include <ydb/library/yql/core/yql_expr_type_annotation.h>
 #include <ydb/library/yql/utils/yql_paths.h>
@@ -14,6 +15,7 @@
 namespace NSQLTranslationV1 {
 
 using NALPDefault::SQLv1LexerTokens;
+using NALPDefaultAntlr4::SQLv1Antlr4Lexer;
 
 using namespace NSQLv1Generated;
 
@@ -218,8 +220,8 @@ bool TSqlQuery::Statement(TVector<TNodePtr>& blocks, const TRule_sql_stmt_core&
             if (rule.HasBlock2()) { // OR REPLACE
                 replaceIfExists = true;
                 Y_DEBUG_ABORT_UNLESS(
-                    rule.GetBlock2().GetToken1().GetId() == SQLv1LexerTokens::TOKEN_OR &&
-                    rule.GetBlock2().GetToken2().GetId() == SQLv1LexerTokens::TOKEN_REPLACE
+                    (IS_TOKEN(rule.GetBlock2().GetToken1().GetId(), OR) && 
+                     IS_TOKEN(rule.GetBlock2().GetToken2().GetId(), REPLACE))
                 );
             }
 
@@ -227,22 +229,26 @@ bool TSqlQuery::Statement(TVector<TNodePtr>& blocks, const TRule_sql_stmt_core&
             const auto& block = rule.GetBlock3();
             ETableType tableType = ETableType::Table;
             bool temporary = false;
-            if (block.HasAlt2() && block.GetAlt2().GetToken1().GetId() == SQLv1LexerTokens::TOKEN_TABLESTORE) {
+            if (block.HasAlt2() &&
+                IS_TOKEN(block.GetAlt2().GetToken1().GetId(), TABLESTORE)
+            ) {
                 tableType = ETableType::TableStore;
                 if (isCreateTableAs) {
                     Context().Error(GetPos(block.GetAlt2().GetToken1()))
                         << "CREATE TABLE AS is not supported for TABLESTORE";
                     return false;
                 }
-            } else if (block.HasAlt3() && block.GetAlt3().GetToken1().GetId() == SQLv1LexerTokens::TOKEN_EXTERNAL) {
+            } else if (block.HasAlt3() &&
+                       IS_TOKEN(block.GetAlt3().GetToken1().GetId(), EXTERNAL)
+                    ) {
                 tableType = ETableType::ExternalTable;
                 if (isCreateTableAs) {
                     Context().Error(GetPos(block.GetAlt3().GetToken1()))
                         << "CREATE TABLE AS is not supported for EXTERNAL TABLE";
                     return false;
                 }
-            } else if (block.HasAlt4() && block.GetAlt4().GetToken1().GetId() == SQLv1LexerTokens::TOKEN_TEMP ||
-                    block.HasAlt5() && block.GetAlt5().GetToken1().GetId() == SQLv1LexerTokens::TOKEN_TEMPORARY) {
+            } else if (block.HasAlt4() && IS_TOKEN(block.GetAlt4().GetToken1().GetId(), TEMP) ||
+                       block.HasAlt5() && IS_TOKEN(block.GetAlt5().GetToken1().GetId(), TEMPORARY)) {
                 temporary = true;
             }
 
@@ -250,9 +256,9 @@ bool TSqlQuery::Statement(TVector<TNodePtr>& blocks, const TRule_sql_stmt_core&
             if (rule.HasBlock4()) { // IF NOT EXISTS
                 existingOk = true;
                 Y_DEBUG_ABORT_UNLESS(
-                    rule.GetBlock4().GetToken1().GetId() == SQLv1LexerTokens::TOKEN_IF &&
-                    rule.GetBlock4().GetToken2().GetId() == SQLv1LexerTokens::TOKEN_NOT &&
-                    rule.GetBlock4().GetToken3().GetId() == SQLv1LexerTokens::TOKEN_EXISTS
+                    IS_TOKEN(rule.GetBlock4().GetToken1().GetId(), IF) &&
+                    IS_TOKEN(rule.GetBlock4().GetToken2().GetId(), NOT) &&
+                    IS_TOKEN(rule.GetBlock4().GetToken3().GetId(), EXISTS)
                 );
             }
 
@@ -339,8 +345,8 @@ bool TSqlQuery::Statement(TVector<TNodePtr>& blocks, const TRule_sql_stmt_core&
             if (rule.HasBlock3()) { // IF EXISTS
                 missingOk = true;
                 Y_DEBUG_ABORT_UNLESS(
-                    rule.GetBlock3().GetToken1().GetId() == SQLv1LexerTokens::TOKEN_IF &&
-                    rule.GetBlock3().GetToken2().GetId() == SQLv1LexerTokens::TOKEN_EXISTS
+                    IS_TOKEN(rule.GetBlock3().GetToken1().GetId(), IF) &&
+                    IS_TOKEN(rule.GetBlock3().GetToken2().GetId(), EXISTS)
                 );
             }
 
@@ -431,7 +437,7 @@ bool TSqlQuery::Statement(TVector<TNodePtr>& blocks, const TRule_sql_stmt_core&
         case TRule_sql_stmt_core::kAltSqlStmtCore15: {
             Ctx.BodyPart();
             const auto& rule = core.GetAlt_sql_stmt_core15().GetRule_alter_table_stmt1();
-            const bool isTablestore = rule.GetToken2().GetId() == SQLv1LexerTokens::TOKEN_TABLESTORE;
+            const bool isTablestore = IS_TOKEN(rule.GetToken2().GetId(), TABLESTORE);
             TTableRef tr;
             if (!SimpleTableRefImpl(rule.GetRule_simple_table_ref3(), tr)) {
                 return false;
@@ -697,7 +703,7 @@ bool TSqlQuery::Statement(TVector<TNodePtr>& blocks, const TRule_sql_stmt_core&
             switch (node.GetBlock4().Alt_case()) {
                 case TRule_alter_group_stmt_TBlock4::kAlt1: {
                     auto& addDropNode = node.GetBlock4().GetAlt1();
-                    const bool isDrop = addDropNode.GetToken1().GetId() == SQLv1LexerTokens::TOKEN_DROP;
+                    const bool isDrop = IS_TOKEN(addDropNode.GetToken1().GetId(), DROP);
                     TVector<TDeferredAtom> roles;
                     bool allowSystemRoles = false;
                     roles.emplace_back();
@@ -746,13 +752,13 @@ bool TSqlQuery::Statement(TVector<TNodePtr>& blocks, const TRule_sql_stmt_core&
                 return false;
             }
 
-            const bool isUser = node.GetToken2().GetId() == SQLv1LexerTokens::TOKEN_USER;
+            const bool isUser = IS_TOKEN(node.GetToken2().GetId(), USER);
             bool missingOk = false;
             if (node.HasBlock3()) { // IF EXISTS
                 missingOk = true;
                 Y_DEBUG_ABORT_UNLESS(
-                    node.GetBlock3().GetToken1().GetId() == SQLv1LexerTokens::TOKEN_IF &&
-                    node.GetBlock3().GetToken2().GetId() == SQLv1LexerTokens::TOKEN_EXISTS
+                    IS_TOKEN(node.GetBlock3().GetToken1().GetId(), IF) &&
+                    IS_TOKEN(node.GetBlock3().GetToken2().GetId(), EXISTS)
                 );
             }
 
@@ -788,9 +794,9 @@ bool TSqlQuery::Statement(TVector<TNodePtr>& blocks, const TRule_sql_stmt_core&
             if (node.HasBlock3()) { // IF NOT EXISTS
                 existingOk = true;
                 Y_DEBUG_ABORT_UNLESS(
-                    node.GetBlock3().GetToken1().GetId() == SQLv1LexerTokens::TOKEN_IF &&
-                    node.GetBlock3().GetToken2().GetId() == SQLv1LexerTokens::TOKEN_NOT &&
-                    node.GetBlock3().GetToken3().GetId() == SQLv1LexerTokens::TOKEN_EXISTS
+                    IS_TOKEN(node.GetBlock3().GetToken1().GetId(), IF) &&
+                    IS_TOKEN(node.GetBlock3().GetToken2().GetId(), NOT) &&
+                    IS_TOKEN(node.GetBlock3().GetToken3().GetId(), EXISTS)
                 );
             }
 
@@ -842,8 +848,8 @@ bool TSqlQuery::Statement(TVector<TNodePtr>& blocks, const TRule_sql_stmt_core&
             if (node.HasBlock3()) { // IF EXISTS
                 missingOk = true;
                 Y_DEBUG_ABORT_UNLESS(
-                    node.GetBlock3().GetToken1().GetId() == SQLv1LexerTokens::TOKEN_IF &&
-                    node.GetBlock3().GetToken2().GetId() == SQLv1LexerTokens::TOKEN_EXISTS
+                    IS_TOKEN(node.GetBlock3().GetToken1().GetId(), IF) &&
+                    IS_TOKEN(node.GetBlock3().GetToken2().GetId(), EXISTS)
                 );
             }
 
@@ -874,8 +880,8 @@ bool TSqlQuery::Statement(TVector<TNodePtr>& blocks, const TRule_sql_stmt_core&
             if (node.HasBlock2()) { // OR REPLACE
                 replaceIfExists = true;
                 Y_DEBUG_ABORT_UNLESS(
-                    node.GetBlock2().GetToken1().GetId() == SQLv1LexerTokens::TOKEN_OR &&
-                    node.GetBlock2().GetToken2().GetId() == SQLv1LexerTokens::TOKEN_REPLACE
+                    IS_TOKEN(node.GetBlock2().GetToken1().GetId(), OR) &&
+                    IS_TOKEN(node.GetBlock2().GetToken2().GetId(), REPLACE)
                 );
             }
 
@@ -883,9 +889,9 @@ bool TSqlQuery::Statement(TVector<TNodePtr>& blocks, const TRule_sql_stmt_core&
             if (node.HasBlock6()) { // IF NOT EXISTS
                 existingOk = true;
                 Y_DEBUG_ABORT_UNLESS(
-                    node.GetBlock6().GetToken1().GetId() == SQLv1LexerTokens::TOKEN_IF &&
-                    node.GetBlock6().GetToken2().GetId() == SQLv1LexerTokens::TOKEN_NOT &&
-                    node.GetBlock6().GetToken3().GetId() == SQLv1LexerTokens::TOKEN_EXISTS
+                    IS_TOKEN(node.GetBlock6().GetToken1().GetId(), IF) &&
+                    IS_TOKEN(node.GetBlock6().GetToken2().GetId(), NOT) &&
+                    IS_TOKEN(node.GetBlock6().GetToken3().GetId(), EXISTS)
                 );
             }
 
@@ -941,8 +947,8 @@ bool TSqlQuery::Statement(TVector<TNodePtr>& blocks, const TRule_sql_stmt_core&
             if (node.HasBlock5()) { // IF EXISTS
                 missingOk = true;
                 Y_DEBUG_ABORT_UNLESS(
-                    node.GetBlock5().GetToken1().GetId() == SQLv1LexerTokens::TOKEN_IF &&
-                    node.GetBlock5().GetToken2().GetId() == SQLv1LexerTokens::TOKEN_EXISTS
+                    IS_TOKEN(node.GetBlock5().GetToken1().GetId(), IF) &&
+                    IS_TOKEN(node.GetBlock5().GetToken2().GetId(), EXISTS)
                 );
             }
 
diff --git a/ydb/library/yql/sql/v1/sql_query.h b/ydb/library/yql/sql/v1/sql_query.h
index be9bc56121d0..fc0551b778f8 100644
--- a/ydb/library/yql/sql/v1/sql_query.h
+++ b/ydb/library/yql/sql/v1/sql_query.h
@@ -61,9 +61,13 @@ class TSqlQuery: public TSqlTranslation {
         humanStatementName.clear();
         const auto& descr = AltDescription(node);
         TVector<TString> parts;
-        const auto pos = descr.find(": ");
-        Y_DEBUG_ABORT_UNLESS(pos != TString::npos);
-        Split(TString(descr.begin() + pos + 2, descr.end()), "_", parts);
+        if (!Ctx.Settings.Antlr4Parser) {
+            const auto pos = descr.find(": ");
+            Y_DEBUG_ABORT_UNLESS(pos != TString::npos);
+            Split(TString(descr.begin() + pos + 2, descr.end()), "_", parts);   
+        } else {
+            Split(descr, "_", parts);
+        }
         Y_DEBUG_ABORT_UNLESS(parts.size() > 1);
         parts.pop_back();
         for (auto& part: parts) {
diff --git a/ydb/library/yql/sql/v1/sql_translation.cpp b/ydb/library/yql/sql/v1/sql_translation.cpp
index 2cbb2ddd2fab..9acadbca583c 100644
--- a/ydb/library/yql/sql/v1/sql_translation.cpp
+++ b/ydb/library/yql/sql/v1/sql_translation.cpp
@@ -7,6 +7,7 @@
 #include "source.h"
 
 #include <ydb/library/yql/parser/proto_ast/gen/v1/SQLv1Lexer.h>
+#include <ydb/library/yql/parser/proto_ast/gen/v1_antlr4/SQLv1Antlr4Lexer.h>
 #include <ydb/library/yql/sql/settings/partitioning.h>
 
 #include <util/generic/scope.h>
@@ -85,6 +86,7 @@ TNodePtr BuildViewSelect(const TRule_select_stmt& query, TContext& ctx) {
 namespace NSQLTranslationV1 {
 
 using NALPDefault::SQLv1LexerTokens;
+using NALPDefaultAntlr4::SQLv1Antlr4Lexer;
 
 using namespace NSQLv1Generated;
 
@@ -1612,15 +1614,15 @@ bool TSqlTranslation::CreateTableEntry(const TRule_create_table_entry& node, TCr
                         }
 
                         auto& token = spec.GetBlock2().GetToken1();
-                        switch (token.GetId()) {
-                            case SQLv1LexerTokens::TOKEN_ASC:
-                                return true;
-                            case SQLv1LexerTokens::TOKEN_DESC:
-                                desc = true;
-                                return true;
-                            default:
-                                Ctx.Error() << "Unsupported direction token: " << token.GetId();
-                                return false;
+                        auto tokenId = token.GetId();
+                        if (IS_TOKEN(tokenId, ASC)) {
+                            return true;
+                        } else if (IS_TOKEN(tokenId, DESC)) {
+                            desc = true;
+                            return true;
+                        } else {
+                            Ctx.Error() << "Unsupported direction token: " << token.GetId();
+                            return false;
                         }
                     };
 
@@ -3606,18 +3608,16 @@ bool TSqlTranslation::SortSpecification(const TRule_sort_specification& node, TV
     if (node.HasBlock2()) {
         const auto& token = node.GetBlock2().GetToken1();
         Token(token);
-        switch (token.GetId()) {
-            case SQLv1LexerTokens::TOKEN_ASC:
-                Ctx.IncrementMonCounter("sql_features", "OrderByAsc");
-                break;
-            case SQLv1LexerTokens::TOKEN_DESC:
-                asc = false;
-                Ctx.IncrementMonCounter("sql_features", "OrderByDesc");
-                break;
-            default:
-                Ctx.IncrementMonCounter("sql_errors", "UnknownOrderBy");
-                Error() << "Unsupported direction token: " << token.GetId();
-                return false;
+        auto tokenId = token.GetId();
+        if (IS_TOKEN(tokenId, ASC)) {
+            Ctx.IncrementMonCounter("sql_features", "OrderByAsc");
+        } else if (IS_TOKEN(tokenId, DESC)) {
+            asc = false;
+            Ctx.IncrementMonCounter("sql_features", "OrderByDesc");
+        } else {
+            Ctx.IncrementMonCounter("sql_errors", "UnknownOrderBy");
+            Error() << "Unsupported direction token: " << token.GetId();
+            return false;
         }
     } else {
         Ctx.IncrementMonCounter("sql_features", "OrderByDefault");
@@ -3641,11 +3641,11 @@ bool TSqlTranslation::SortSpecificationList(const TRule_sort_specification_list&
 
 bool TSqlTranslation::IsDistinctOptSet(const TRule_opt_set_quantifier& node) const {
     TPosition pos;
-    return node.HasBlock1() && node.GetBlock1().GetToken1().GetId() == SQLv1LexerTokens::TOKEN_DISTINCT;
+    return node.HasBlock1() && IS_TOKEN(node.GetBlock1().GetToken1().GetId(), DISTINCT);
 }
 
 bool TSqlTranslation::IsDistinctOptSet(const TRule_opt_set_quantifier& node, TPosition& distinctPos) const {
-    if (node.HasBlock1() && node.GetBlock1().GetToken1().GetId() == SQLv1LexerTokens::TOKEN_DISTINCT) {
+    if (node.HasBlock1() && IS_TOKEN(node.GetBlock1().GetToken1().GetId(), DISTINCT)) {
         distinctPos = Ctx.TokenPosition(node.GetBlock1().GetToken1());
         return true;
     }
diff --git a/ydb/library/yql/sql/v1/sql_ut.cpp b/ydb/library/yql/sql/v1/sql_ut.cpp
index 0906c1b19eff..9242752f1798 100644
--- a/ydb/library/yql/sql/v1/sql_ut.cpp
+++ b/ydb/library/yql/sql/v1/sql_ut.cpp
@@ -17,7 +17,7 @@ using namespace NSQLTranslation;
 namespace {
 
 TParsedTokenList Tokenize(const TString& query) {
-    auto lexer = NSQLTranslationV1::MakeLexer(true);
+    auto lexer = NSQLTranslationV1::MakeLexer(true, false);
     TParsedTokenList tokens;
     NYql::TIssues issues;
     UNIT_ASSERT_C(Tokenize(*lexer, query, "Query", tokens, issues, SQL_MAX_PARSER_ERRORS),
diff --git a/ydb/library/yql/sql/v1/sql_ut.h b/ydb/library/yql/sql/v1/sql_ut.h
index 0448f31000f0..c5846579ba0e 100644
--- a/ydb/library/yql/sql/v1/sql_ut.h
+++ b/ydb/library/yql/sql/v1/sql_ut.h
@@ -41,6 +41,7 @@ inline NYql::TAstParseResult SqlToYqlWithMode(const TString& query, NSQLTranslat
     settings.Mode = mode;
     settings.Arena = &arena;
     settings.AnsiLexer = ansiLexer;
+    settings.Antlr4Parser = false;
     settings.SyntaxVersion = 1;
     auto res = SqlToYql(query, settings);
     if (debug == EDebugOutput::ToCerr) {
@@ -53,7 +54,8 @@ inline NYql::TAstParseResult SqlToYql(const TString& query, size_t maxErrors = 1
     return SqlToYqlWithMode(query, NSQLTranslation::ESqlMode::QUERY, maxErrors, provider, debug);
 }
 
-inline NYql::TAstParseResult SqlToYqlWithSettings(const TString& query, const NSQLTranslation::TTranslationSettings& settings) {
+inline NYql::TAstParseResult 
+SqlToYqlWithSettings(const TString& query, const NSQLTranslation::TTranslationSettings& settings) {
     return SqlToYqlWithMode(query, NSQLTranslation::ESqlMode::QUERY, 10, {}, EDebugOutput::None, false, settings);
 }
 
diff --git a/ydb/library/yql/sql/v1/sql_ut_antlr4.cpp b/ydb/library/yql/sql/v1/sql_ut_antlr4.cpp
new file mode 100644
index 000000000000..7602687765fe
--- /dev/null
+++ b/ydb/library/yql/sql/v1/sql_ut_antlr4.cpp
@@ -0,0 +1,7203 @@
+#include "sql_ut_antlr4.h"
+#include "format/sql_format.h"
+#include "lexer/lexer.h"
+
+#include <ydb/library/yql/providers/common/provider/yql_provider_names.h>
+#include <ydb/library/yql/sql/sql.h>
+#include <util/generic/map.h>
+
+#include <library/cpp/testing/unittest/registar.h>
+
+#include <util/string/split.h>
+
+#include <format>
+
+using namespace NSQLTranslation;
+
+namespace {
+
+TParsedTokenList Tokenize(const TString& query) {
+    auto lexer = NSQLTranslationV1::MakeLexer(true, true);
+    TParsedTokenList tokens;
+    NYql::TIssues issues;
+    UNIT_ASSERT_C(Tokenize(*lexer, query, "Query", tokens, issues, SQL_MAX_PARSER_ERRORS),
+                  issues.ToString());
+
+    return tokens;
+}
+
+TString ToString(const TParsedTokenList& tokens) {
+    TStringBuilder reconstructedQuery;
+    for (const auto& token : tokens) {
+        if (token.Name == "WS" || token.Name == "EOF") {
+            continue;
+        }
+        if (!reconstructedQuery.Empty()) {
+            reconstructedQuery << ' ';
+        }
+        reconstructedQuery << token.Content;
+    }
+    return reconstructedQuery;
+}
+
+}
+
+Y_UNIT_TEST_SUITE(AnsiMode) {
+    Y_UNIT_TEST(PragmaAnsi) {
+        UNIT_ASSERT(SqlToYql("PRAGMA ANSI 2016;").IsOk());
+    }
+}
+
+Y_UNIT_TEST_SUITE(SqlParsingOnly) {
+    ///This function is used in BACKWARD COMPATIBILITY tests below that LIMIT the sets of token that CAN NOT be used
+    ///as identifiers in different contexts in a SQL request
+    ///\return list of tokens that failed this check
+    TVector<TString> ValidateTokens(const THashSet<TString>& forbidden, const std::function<TString (const TString& )>& makeRequest) {
+        THashMap<TString, bool> allTokens;
+        for (const auto& t: NSQLFormat::GetKeywords()) {
+            allTokens[t] = !forbidden.contains((t));
+        }
+        for (const auto& f: forbidden) {
+            UNIT_ASSERT(allTokens.contains(f)); //check that forbidden list contains tokens only(argument check)
+        }
+        TVector<TString> failed;
+        for (const auto& [token, allowed]: allTokens) {
+            if (SqlToYql(makeRequest(token)).IsOk() != allowed)
+               failed.push_back(token);
+        }
+        return failed;
+    }
+
+    Y_UNIT_TEST(TokensAsColumnName) { //id_expr
+        auto failed = ValidateTokens({
+                "ALL", "ANY", "AS", "ASSUME", "ASYMMETRIC", "AUTOMAP", "BETWEEN", "BITCAST",
+                "CALLABLE", "CASE", "CAST", "CUBE", "CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP",
+                "DICT", "DISTINCT", "ENUM", "ERASE", "EXCEPT", "EXISTS", "FLOW", "FROM", "FULL", "GLOBAL",
+                "HAVING", "HOP", "INTERSECT", "JSON_EXISTS", "JSON_QUERY", "JSON_VALUE", "LIMIT", "LIST", "LOCAL",
+                "NOT", "OPTIONAL", "PROCESS", "REDUCE", "REPEATABLE", "RESOURCE", "RETURN", "RETURNING", "ROLLUP",
+                "SELECT", "SET", "STREAM", "STRUCT", "SYMMETRIC", "TAGGED", "TUPLE", "UNBOUNDED",
+                "UNION", "VARIANT", "WHEN", "WHERE", "WINDOW", "WITHOUT"
+            },
+            [](const TString& token){
+                TStringBuilder req;
+                req << "SELECT " << token << " FROM Plato.Input";
+                return req;
+            }
+        );
+        UNIT_ASSERT_VALUES_EQUAL(failed, TVector<TString>{});
+    }
+
+    Y_UNIT_TEST(TokensAsWithoutColumnName) { //id_without
+        auto failed = ValidateTokens({
+                "ALL", "AS", "ASSUME", "ASYMMETRIC", "AUTOMAP", "BETWEEN", "BITCAST",
+                "CALLABLE", "CASE", "CAST", "CUBE", "CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP",
+                "DICT", "DISTINCT", "EMPTY_ACTION", "ENUM", "EXCEPT", "EXISTS", "FALSE", "FLOW", "FROM", "FULL", "GLOBAL",
+                "HAVING", "HOP", "INTERSECT", "JSON_EXISTS", "JSON_QUERY", "JSON_VALUE", "LIMIT", "LIST", "LOCAL",
+                "NOT", "NULL", "OPTIONAL", "PROCESS", "REDUCE", "REPEATABLE", "RESOURCE", "RETURN", "RETURNING", "ROLLUP",
+                "SELECT", "SET", "STRUCT", "SYMMETRIC", "TAGGED", "TRUE", "TUPLE", "UNBOUNDED",
+                "UNION", "VARIANT", "WHEN", "WHERE", "WINDOW", "WITHOUT"
+             },
+             [](const TString& token){
+                 TStringBuilder req;
+                 req << "SELECT * WITHOUT " << token << " FROM Plato.Input";
+                 return req;
+             }
+        );
+        UNIT_ASSERT_VALUES_EQUAL(failed, TVector<TString>{});
+    }
+
+    Y_UNIT_TEST(TokensAsColumnNameInAddColumn) { //id_schema
+        auto failed = ValidateTokens({
+                "ANY", "AUTOMAP", "CALLABLE", "COLUMN", "DICT", "ENUM", "ERASE", "FALSE", "FLOW",
+                "GLOBAL", "LIST", "OPTIONAL", "REPEATABLE", "RESOURCE",
+                "SET", "STREAM", "STRUCT", "TAGGED", "TRUE", "TUPLE", "VARIANT"
+            },
+            [](const TString& token){
+                 TStringBuilder req;
+                 req << "ALTER TABLE Plato.Input ADD COLUMN " << token << " Bool";
+                 return req;
+            }
+        );
+        UNIT_ASSERT_VALUES_EQUAL(failed, TVector<TString>{});
+    }
+
+    Y_UNIT_TEST(TokensAsColumnAlias) {
+        auto failed = ValidateTokens({
+                 "AUTOMAP", "FALSE",
+                 "GLOBAL", "REPEATABLE", "TRUE"
+             },
+             [](const TString& token){
+                 TStringBuilder req;
+                 req << "SELECT Col as " << token << " FROM Plato.Input";
+                 return req;
+             }
+        );
+        UNIT_ASSERT_VALUES_EQUAL(failed, TVector<TString>{});
+    }
+
+    Y_UNIT_TEST(TokensAsTableName) { //id_table_or_type
+        auto failed = ValidateTokens({
+                "ANY", "AUTOMAP", "COLUMN", "ERASE", "FALSE",
+                "GLOBAL", "REPEATABLE", "STREAM", "TRUE"
+            },
+            [](const TString& token){
+                TStringBuilder req;
+                req << "SELECT * FROM Plato." << token;
+                return req;
+            }
+        );
+        UNIT_ASSERT_VALUES_EQUAL(failed, TVector<TString>{});
+    }
+
+    Y_UNIT_TEST(TokensAsTableAlias) { //id_table
+        auto failed = ValidateTokens({
+                "AUTOMAP", "CALLABLE", "DICT", "ENUM","FALSE", "FLOW",
+                "GLOBAL", "LIST", "OPTIONAL", "REPEATABLE", "RESOURCE",
+                "SET", "STRUCT", "TAGGED", "TRUE", "TUPLE", "VARIANT"
+            },
+            [](const TString& token){
+                 TStringBuilder req;
+                 req << "SELECT * FROM Plato.Input AS " << token;
+                 return req;
+            }
+        );
+        UNIT_ASSERT_VALUES_EQUAL(failed, TVector<TString>{});
+    }
+
+    Y_UNIT_TEST(TokensAsHints) { //id_hint
+        auto failed = ValidateTokens({
+                "AUTOMAP", "CALLABLE", "COLUMNS", "DICT", "ENUM", "FALSE", "FLOW",
+                "GLOBAL", "LIST", "OPTIONAL", "REPEATABLE", "RESOURCE",
+                "SCHEMA", "SET", "STRUCT", "TAGGED", "TRUE", "TUPLE", "VARIANT"
+            },
+            [](const TString& token){
+                TStringBuilder req;
+                req << "SELECT * FROM Plato.Input WITH " << token;
+                return req;
+            }
+        );
+        UNIT_ASSERT_VALUES_EQUAL(failed, TVector<TString>{});
+    }
+
+    Y_UNIT_TEST(TokensAsWindow) { //id_window
+        auto failed = ValidateTokens({
+                "AUTOMAP", "CALLABLE", "DICT", "ENUM", "FALSE", "FLOW", "GLOBAL", "GROUPS", "LIST", "OPTIONAL",
+                "RANGE", "REPEATABLE", "RESOURCE", "ROWS", "SET", "STRUCT", "TAGGED" ,"TRUE", "TUPLE", "VARIANT"
+            },
+            [](const TString& token){
+                TStringBuilder req;
+                req << "SELECT * FROM Plato.Input WINDOW " << token << " AS ()";
+                return req;
+            }
+        );
+        UNIT_ASSERT_VALUES_EQUAL(failed, TVector<TString>{});
+    }
+
+    Y_UNIT_TEST(TokensAsIdExprIn) { //id_expr_in
+        auto failed = ValidateTokens({
+                "ALL", "ANY", "AS", "ASSUME", "ASYMMETRIC", "AUTOMAP", "BETWEEN", "BITCAST",
+                "CALLABLE", "CASE", "CAST", "COMPACT", "CUBE", "CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP",
+                "DICT", "DISTINCT", "ENUM", "ERASE", "EXCEPT", "EXISTS", "FLOW", "FROM", "FULL", "GLOBAL",
+                "HAVING", "HOP", "INTERSECT", "JSON_EXISTS", "JSON_QUERY", "JSON_VALUE", "LIMIT", "LIST", "LOCAL",
+                "NOT", "OPTIONAL", "PROCESS", "REDUCE", "REPEATABLE", "RESOURCE", "RETURN", "RETURNING", "ROLLUP",
+                "SELECT", "SET", "STREAM", "STRUCT", "SYMMETRIC", "TAGGED", "TUPLE", "UNBOUNDED",
+                "UNION", "VARIANT", "WHEN", "WHERE", "WINDOW", "WITHOUT"
+            },
+            [](const TString& token){
+                TStringBuilder req;
+                req << "SELECT * FROM Plato.Input WHERE q IN " << token;
+                return req;
+            }
+        );
+        UNIT_ASSERT_VALUES_EQUAL(failed, TVector<TString>{});
+    }
+
+    Y_UNIT_TEST(TableHints) {
+        UNIT_ASSERT(SqlToYql("SELECT * FROM plato.Input WITH INFER_SCHEMA").IsOk());
+        UNIT_ASSERT(SqlToYql("SELECT * FROM plato.Input WITH (INFER_SCHEMA)").IsOk());
+    }
+
+    Y_UNIT_TEST(InNoHints) {
+        TString query = "SELECT * FROM plato.Input WHERE key IN (1,2,3)";
+
+        VerifySqlInHints(query, { "'('('warnNoAnsi))" }, {});
+        VerifySqlInHints(query, { "'()" }, false);
+        VerifySqlInHints(query, { "'('('ansi))" }, true);
+    }
+
+    Y_UNIT_TEST(InHintCompact) {
+        // should parse COMPACT as hint
+        TString query = "SELECT * FROM plato.Input WHERE key IN COMPACT(1, 2, 3)";
+
+        VerifySqlInHints(query, { "'('isCompact)" });
+    }
+
+    Y_UNIT_TEST(InHintSubquery) {
+        // should parse tableSource as hint
+        TString query = "$subq = (SELECT key FROM plato.Input); SELECT * FROM plato.Input WHERE key IN $subq";
+
+        VerifySqlInHints(query, { "'('tableSource)" });
+    }
+
+    Y_UNIT_TEST(InHintCompactSubquery) {
+        TString query = "$subq = (SELECT key FROM plato.Input); SELECT * FROM plato.Input WHERE key IN COMPACT $subq";
+
+        VerifySqlInHints(query, { "'('isCompact)", "'('tableSource)" });
+    }
+
+    Y_UNIT_TEST(CompactKeywordNotReservedForNames) {
+        UNIT_ASSERT(SqlToYql("SELECT COMPACT FROM plato.Input WHERE COMPACT IN COMPACT(1, 2, 3)").IsOk());
+        UNIT_ASSERT(SqlToYql("USE plato; SELECT * FROM COMPACT").IsOk());
+    }
+
+    Y_UNIT_TEST(FamilyKeywordNotReservedForNames) {
+        // FIXME: check if we can get old behaviour
+        //UNIT_ASSERT(SqlToYql("USE plato; CREATE TABLE FAMILY (FAMILY Uint32, PRIMARY KEY (FAMILY));").IsOk());
+        //UNIT_ASSERT(SqlToYql("USE plato; SELECT FAMILY FROM FAMILY").IsOk());
+        UNIT_ASSERT(SqlToYql("USE plato; SELECT FAMILY FROM Input").IsOk());
+    }
+
+    Y_UNIT_TEST(ResetKeywordNotReservedForNames) {
+        UNIT_ASSERT(SqlToYql("USE plato; CREATE TABLE RESET (RESET Uint32, PRIMARY KEY (RESET));").IsOk());
+        UNIT_ASSERT(SqlToYql("USE plato; SELECT RESET FROM RESET").IsOk());
+    }
+
+    Y_UNIT_TEST(SyncKeywordNotReservedForNames) {
+        UNIT_ASSERT(SqlToYql("USE plato; CREATE TABLE SYNC (SYNC Uint32, PRIMARY KEY (SYNC));").IsOk());
+        UNIT_ASSERT(SqlToYql("USE plato; SELECT SYNC FROM SYNC").IsOk());
+    }
+
+    Y_UNIT_TEST(AsyncKeywordNotReservedForNames) {
+        UNIT_ASSERT(SqlToYql("USE plato; CREATE TABLE ASYNC (ASYNC Uint32, PRIMARY KEY (ASYNC));").IsOk());
+        UNIT_ASSERT(SqlToYql("USE plato; SELECT ASYNC FROM ASYNC").IsOk());
+    }
+
+    Y_UNIT_TEST(DisableKeywordNotReservedForNames) {
+        UNIT_ASSERT(SqlToYql("USE plato; CREATE TABLE DISABLE (DISABLE Uint32, PRIMARY KEY (DISABLE));").IsOk());
+        UNIT_ASSERT(SqlToYql("USE plato; SELECT DISABLE FROM DISABLE").IsOk());
+    }
+
+    Y_UNIT_TEST(ChangefeedKeywordNotReservedForNames) {
+        UNIT_ASSERT(SqlToYql("USE plato; CREATE TABLE CHANGEFEED (CHANGEFEED Uint32, PRIMARY KEY (CHANGEFEED));").IsOk());
+        UNIT_ASSERT(SqlToYql("USE plato; SELECT CHANGEFEED FROM CHANGEFEED").IsOk());
+    }
+
+    Y_UNIT_TEST(ReplicationKeywordNotReservedForNames) {
+        UNIT_ASSERT(SqlToYql("USE plato; CREATE TABLE REPLICATION (REPLICATION Uint32, PRIMARY KEY (REPLICATION));").IsOk());
+        UNIT_ASSERT(SqlToYql("USE plato; SELECT REPLICATION FROM REPLICATION").IsOk());
+    }
+
+    Y_UNIT_TEST(SecondsKeywordNotReservedForNames) {
+        UNIT_ASSERT(SqlToYql("USE plato; CREATE TABLE SECONDS (SECONDS Uint32, PRIMARY KEY (SECONDS));").IsOk());
+        UNIT_ASSERT(SqlToYql("USE plato; SELECT SECONDS FROM SECONDS").IsOk());
+    }
+
+    Y_UNIT_TEST(MillisecondsKeywordNotReservedForNames) {
+        UNIT_ASSERT(SqlToYql("USE plato; CREATE TABLE MILLISECONDS (MILLISECONDS Uint32, PRIMARY KEY (MILLISECONDS));").IsOk());
+        UNIT_ASSERT(SqlToYql("USE plato; SELECT MILLISECONDS FROM MILLISECONDS").IsOk());
+    }
+
+    Y_UNIT_TEST(MicrosecondsKeywordNotReservedForNames) {
+        UNIT_ASSERT(SqlToYql("USE plato; CREATE TABLE MICROSECONDS (MICROSECONDS Uint32, PRIMARY KEY (MICROSECONDS));").IsOk());
+        UNIT_ASSERT(SqlToYql("USE plato; SELECT MICROSECONDS FROM MICROSECONDS").IsOk());
+    }
+
+    Y_UNIT_TEST(NanosecondsKeywordNotReservedForNames) {
+        UNIT_ASSERT(SqlToYql("USE plato; CREATE TABLE NANOSECONDS (NANOSECONDS Uint32, PRIMARY KEY (NANOSECONDS));").IsOk());
+        UNIT_ASSERT(SqlToYql("USE plato; SELECT NANOSECONDS FROM NANOSECONDS").IsOk());
+    }
+
+    Y_UNIT_TEST(Jubilee) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; INSERT INTO Arcadia (r2000000) VALUES (\"2M GET!!!\");");
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(QualifiedAsteriskBefore) {
+        NYql::TAstParseResult res = SqlToYql(
+            "PRAGMA DisableSimpleColumns;"
+            "select interested_table.*, LENGTH(value) AS megahelpful_len  from plato.Input as interested_table;"
+        );
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            static bool seenStar = false;
+            if (word == "FlattenMembers") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("interested_table."));
+            } else if (word == "SqlProjectItem") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(Quote("megahelpful_len")));
+                UNIT_ASSERT_VALUES_EQUAL(seenStar, true);
+            } else if (word == "SqlProjectStarItem") {
+                seenStar = true;
+            }
+        };
+        TWordCountHive elementStat = {{TString("FlattenMembers"), 0}, {TString("SqlProjectItem"), 0}, {TString("SqlProjectStarItem"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["FlattenMembers"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["SqlProjectItem"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["SqlProjectStarItem"]);
+    }
+
+    Y_UNIT_TEST(QualifiedAsteriskAfter) {
+        NYql::TAstParseResult res = SqlToYql(
+            "PRAGMA DisableSimpleColumns;"
+            "select LENGTH(value) AS megahelpful_len, interested_table.*  from plato.Input as interested_table;"
+        );
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            static bool seenStar = false;
+            if (word == "FlattenMembers") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("interested_table."));
+            } else if (word == "SqlProjectItem") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(Quote("megahelpful_len")));
+                UNIT_ASSERT_VALUES_EQUAL(seenStar, false);
+            } else if (word == "SqlProjectStarItem") {
+                seenStar = true;
+            }
+        };
+        TWordCountHive elementStat = {{TString("FlattenMembers"), 0}, {TString("SqlProjectItem"), 0}, {TString("SqlProjectStarItem"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["FlattenMembers"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["SqlProjectItem"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["SqlProjectStarItem"]);
+    }
+
+    Y_UNIT_TEST(QualifiedMembers) {
+        NYql::TAstParseResult res = SqlToYql("select interested_table.key, interested_table.value from plato.Input as interested_table;");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            const bool fieldKey = TString::npos != line.find(Quote("key"));
+            const bool fieldValue = TString::npos != line.find(Quote("value"));
+            const bool refOnTable = TString::npos != line.find("interested_table.");
+            if (word == "SqlProjectItem") {
+                UNIT_ASSERT(fieldKey || fieldValue);
+                UNIT_ASSERT(!refOnTable);
+            } else if (word == "Write!") {
+                UNIT_ASSERT(fieldKey && fieldValue && !refOnTable);
+            }
+        };
+        TWordCountHive elementStat = {{TString("SqlProjectStarItem"), 0}, {TString("SqlProjectItem"), 0}, {TString("Write!"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+        UNIT_ASSERT_VALUES_EQUAL(0, elementStat["SqlProjectStarItem"]);
+        UNIT_ASSERT_VALUES_EQUAL(2, elementStat["SqlProjectItem"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write!"]);
+    }
+
+    Y_UNIT_TEST(JoinParseCorrect) {
+        NYql::TAstParseResult res = SqlToYql(
+            "PRAGMA DisableSimpleColumns;"
+            " SELECT table_bb.*, table_aa.key as megakey"
+            " FROM plato.Input AS table_aa"
+            " JOIN plato.Input AS table_bb"
+            " ON table_aa.value == table_bb.value;"
+        );
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "SelectMembers") {
+                UNIT_ASSERT_VALUES_EQUAL(TString::npos, line.find("table_aa."));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("table_bb."));
+            } else if (word == "SqlProjectItem") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(Quote("megakey")));
+            } else if (word == "SqlColumn") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(Quote("table_aa")));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(Quote("key")));
+            }
+        };
+        TWordCountHive elementStat = {{TString("SqlProjectItem"), 0}, {TString("SqlProjectStarItem"), 0}, {TString("SelectMembers"), 0}, {TString("SqlColumn"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["SqlProjectItem"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["SqlProjectStarItem"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["SelectMembers"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["SqlColumn"]);
+    }
+
+    Y_UNIT_TEST(Join3Table) {
+        NYql::TAstParseResult res = SqlToYql(
+            " PRAGMA DisableSimpleColumns;"
+            " SELECT table_bb.*, table_aa.key as gigakey, table_cc.* "
+            " FROM plato.Input AS table_aa"
+            " JOIN plato.Input AS table_bb ON table_aa.key == table_bb.key"
+            " JOIN plato.Input AS table_cc ON table_aa.subkey == table_cc.subkey;"
+        );
+        Err2Str(res);
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "SelectMembers") {
+                UNIT_ASSERT_VALUES_EQUAL(TString::npos, line.find("table_aa."));
+                UNIT_ASSERT(line.find("table_bb.") != TString::npos || line.find("table_cc.") != TString::npos);
+            } else if (word == "SqlProjectItem") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(Quote("gigakey")));
+            } else if (word == "SqlColumn") {
+                const auto posTableAA = line.find(Quote("table_aa"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, posTableAA);
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(Quote("key")));
+                UNIT_ASSERT_VALUES_EQUAL(TString::npos, line.find("table_aa", posTableAA + 3));
+            }
+        };
+        TWordCountHive elementStat = {{TString("SqlProjectItem"), 0}, {TString("SqlProjectStarItem"), 0}, {TString("SelectMembers"), 0}, {TString("SqlColumn"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["SqlProjectItem"]);
+        UNIT_ASSERT_VALUES_EQUAL(2, elementStat["SqlProjectStarItem"]);
+        UNIT_ASSERT_VALUES_EQUAL(2, elementStat["SelectMembers"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["SqlColumn"]);
+    }
+
+    Y_UNIT_TEST(DisabledJoinCartesianProduct) {
+        NYql::TAstParseResult res = SqlToYql("pragma DisableAnsiImplicitCrossJoin; use plato; select * from A,B,C");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_STRINGS_EQUAL(res.Issues.ToString(), "<main>:1:67: Error: Cartesian product of tables is disabled. Please use explicit CROSS JOIN or enable it via PRAGMA AnsiImplicitCrossJoin\n");
+    }
+
+    Y_UNIT_TEST(JoinCartesianProduct) {
+        NYql::TAstParseResult res = SqlToYql("pragma AnsiImplicitCrossJoin; use plato; select * from A,B,C");
+        UNIT_ASSERT(res.Root);
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "EquiJoin") {
+                auto pos = line.find("Cross");
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, pos);
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("Cross", pos + 1));
+            }
+        };
+        TWordCountHive elementStat = {{TString("EquiJoin"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["EquiJoin"]);
+    }
+
+    Y_UNIT_TEST(JoinWithoutConcreteColumns) {
+        NYql::TAstParseResult res = SqlToYql(
+            " use plato;"
+            " SELECT a.v, b.value"
+            "     FROM `Input1` VIEW `ksv` AS a"
+            "     JOIN `Input2` AS b"
+            "     ON a.k == b.key;"
+        );
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "SqlProjectItem") {
+                UNIT_ASSERT(line.find(Quote("a.v")) != TString::npos || line.find(Quote("b.value")) != TString::npos);
+            } else if (word == "SqlColumn") {
+                const auto posTableA = line.find(Quote("a"));
+                const auto posTableB = line.find(Quote("b"));
+                if (posTableA != TString::npos) {
+                    UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(Quote("v")));
+                } else {
+                    UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, posTableB);
+                    UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(Quote("value")));
+                }
+            }
+        };
+        TWordCountHive elementStat = {{TString("SqlProjectStarItem"), 0}, {TString("SqlProjectItem"), 0}, {TString("SqlColumn"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+        UNIT_ASSERT_VALUES_EQUAL(0, elementStat["SqlProjectStarItem"]);
+        UNIT_ASSERT_VALUES_EQUAL(2, elementStat["SqlProjectItem"]);
+        UNIT_ASSERT_VALUES_EQUAL(2, elementStat["SqlColumn"]);
+    }
+
+    Y_UNIT_TEST(JoinWithSameValues) {
+        NYql::TAstParseResult res = SqlToYql("SELECT a.value, b.value FROM plato.Input AS a JOIN plato.Input as b ON a.key == b.key;");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "SqlProjectItem") {
+                const bool isValueFromA = TString::npos != line.find(Quote("a.value"));
+                const bool isValueFromB = TString::npos != line.find(Quote("b.value"));
+                UNIT_ASSERT(isValueFromA || isValueFromB);
+            } if (word == "Write!") {
+                UNIT_ASSERT_VALUES_EQUAL(TString::npos, line.find("a.a."));
+                UNIT_ASSERT_VALUES_EQUAL(TString::npos, line.find("b.b."));
+            }
+        };
+        TWordCountHive elementStat = {{TString("SqlProjectStarItem"), 0}, {TString("SqlProjectItem"), 0}, {"Write!", 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+        UNIT_ASSERT_VALUES_EQUAL(0, elementStat["SqlProjectStarItem"]);
+        UNIT_ASSERT_VALUES_EQUAL(2, elementStat["SqlProjectItem"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write!"]);
+    }
+
+    Y_UNIT_TEST(SameColumnsForDifferentTables) {
+        NYql::TAstParseResult res = SqlToYql("SELECT a.key, b.key FROM plato.Input as a JOIN plato.Input as b on a.key==b.key;");
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(SameColumnsForDifferentTablesFullJoin) {
+        NYql::TAstParseResult res = SqlToYql("SELECT a.key, b.key, a.value, b.value FROM plato.Input AS a FULL JOIN plato.Input AS b USING(key);");
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(JoinStreamLookupStrategyHint) {
+        {
+            NYql::TAstParseResult res = SqlToYql("SELECT * FROM plato.Input AS a JOIN /*+ StreamLookup() */ plato.Input AS b USING(key);");
+            UNIT_ASSERT(res.Root);
+        }
+        //case insensitive
+        {
+            NYql::TAstParseResult res = SqlToYql("SELECT * FROM plato.Input AS a JOIN /*+ streamlookup() */ plato.Input AS b USING(key);");
+            UNIT_ASSERT(res.Root);
+        }
+    }
+
+    Y_UNIT_TEST(JoinConflictingStrategyHint) {
+        {
+            NYql::TAstParseResult res = SqlToYql("SELECT * FROM plato.Input AS a JOIN /*+ StreamLookup() */ /*+ Merge() */   plato.Input AS b USING(key);");
+            UNIT_ASSERT(!res.Root);
+            UNIT_ASSERT_STRINGS_EQUAL(res.Issues.ToString(), "<main>:1:91: Error: Conflicting join strategy hints\n");
+        }
+    }
+
+    Y_UNIT_TEST(JoinDuplicatingStrategyHint) {
+        {
+            NYql::TAstParseResult res = SqlToYql("SELECT * FROM plato.Input AS a JOIN /*+ StreamLookup() */ /*+ StreamLookup() */   plato.Input AS b USING(key);");
+            UNIT_ASSERT(!res.Root);
+            UNIT_ASSERT_STRINGS_EQUAL(res.Issues.ToString(), "<main>:1:98: Error: Duplicate join strategy hint\n");
+        }
+    }
+
+    Y_UNIT_TEST(WarnCrossJoinStrategyHint) {
+        NYql::TAstParseResult res = SqlToYql("SELECT * FROM plato.Input AS a CROSS JOIN /*+ merge() */ plato.Input AS b;");
+        UNIT_ASSERT(res.Root);
+        UNIT_ASSERT_STRINGS_EQUAL(res.Issues.ToString(), "<main>:1:32: Warning: Non-default join strategy will not be used for CROSS JOIN, code: 4534\n");
+    }
+
+    Y_UNIT_TEST(WarnCartesianProductStrategyHint) {
+        NYql::TAstParseResult res = SqlToYql("pragma AnsiImplicitCrossJoin; use plato; SELECT * FROM A, /*+ merge() */ B;");
+        UNIT_ASSERT(res.Root);
+        UNIT_ASSERT_STRINGS_EQUAL(res.Issues.ToString(), "<main>:1:74: Warning: Non-default join strategy will not be used for CROSS JOIN, code: 4534\n");
+    }
+
+    Y_UNIT_TEST(WarnUnknownJoinStrategyHint) {
+        NYql::TAstParseResult res = SqlToYql("SELECT * FROM plato.Input AS a JOIN /*+ xmerge() */ plato.Input AS b USING (key);");
+        UNIT_ASSERT(res.Root);
+        UNIT_ASSERT_STRINGS_EQUAL(res.Issues.ToString(), "<main>:1:41: Warning: Unsupported join strategy: xmerge, code: 4534\n");
+    }
+
+    Y_UNIT_TEST(ReverseLabels) {
+        NYql::TAstParseResult res = SqlToYql("select in.key as subkey, subkey as key from plato.Input as in;");
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(AutogenerationAliasWithoutCollisionConflict1) {
+        NYql::TAstParseResult res = SqlToYql("select LENGTH(Value), key as column1 from plato.Input;");
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(AutogenerationAliasWithoutCollision2Conflict2) {
+        NYql::TAstParseResult res = SqlToYql("select key as column0, LENGTH(Value) from plato.Input;");
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(InputAliasForQualifiedAsterisk) {
+        NYql::TAstParseResult res = SqlToYql("use plato; select zyuzya.*, key from plato.Input as zyuzya;");
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(SelectSupportsResultColumnsWithTrailingComma) {
+        NYql::TAstParseResult res = SqlToYql("select a, b, c, from plato.Input;");
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(SelectOrderByLabeledColumn) {
+        NYql::TAstParseResult res = SqlToYql("pragma DisableOrderedColumns; select key as goal from plato.Input order by goal");
+        UNIT_ASSERT(res.Root);
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "DataSource") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("plato"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("Input"));
+
+                UNIT_ASSERT_VALUES_EQUAL(TString::npos, line.find("goal"));
+            } else if (word == "Sort") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("goal"));
+
+                UNIT_ASSERT_VALUES_EQUAL(TString::npos, line.find("key"));
+            }
+        };
+        TWordCountHive elementStat = {{TString("DataSource"), 0}, {TString("Sort"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["DataSource"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Sort"]);
+    }
+
+    Y_UNIT_TEST(SelectOrderBySimpleExpr) {
+        NYql::TAstParseResult res = SqlToYql("select a from plato.Input order by a + a");
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(SelectOrderByDuplicateLabels) {
+        NYql::TAstParseResult res = SqlToYql("select a from plato.Input order by a, a");
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(SelectOrderByExpression) {
+        NYql::TAstParseResult res = SqlToYql("select * from plato.Input as i order by cast(key as uint32) + cast(subkey as uint32)");
+        UNIT_ASSERT(res.Root);
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Sort") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("\"+MayWarn\""));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("key"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("subkey"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("(Bool 'true)"));
+
+                UNIT_ASSERT_VALUES_EQUAL(TString::npos, line.find("i.key"));
+                UNIT_ASSERT_VALUES_EQUAL(TString::npos, line.find("i.subkey"));
+            }
+        };
+        TWordCountHive elementStat = {{TString("Sort"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Sort"]);
+    }
+
+    Y_UNIT_TEST(SelectOrderByExpressionDesc) {
+        NYql::TAstParseResult res = SqlToYql("pragma disablesimplecolumns; select i.*, key, subkey from plato.Input as i order by cast(i.key as uint32) - cast(i.subkey as uint32) desc");
+        UNIT_ASSERT(res.Root);
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Sort") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("\"-MayWarn\""));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("\"key\""));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("\"subkey\""));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("(Bool 'false)"));
+            } else if (word == "Write!") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("'columns"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("\"key\""));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("\"subkey\""));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("prefix"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("\"i.\""));
+            }
+        };
+        TWordCountHive elementStat = {{TString("Sort"), 0}, {TString("Write!"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Sort"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write!"]);
+    }
+
+    Y_UNIT_TEST(SelectOrderByExpressionAsc) {
+        NYql::TAstParseResult res = SqlToYql("select i.key, i.subkey from plato.Input as i order by cast(key as uint32) % cast(i.subkey as uint32) asc");
+        UNIT_ASSERT(res.Root);
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Sort") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("\"%MayWarn\""));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("\"key\""));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("\"subkey\""));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("(Bool 'true)"));
+            } else if (word == "Write!") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("'columns"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("\"key\""));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("\"subkey\""));
+                UNIT_ASSERT_VALUES_EQUAL(TString::npos, line.find("i."));
+            }
+        };
+        TWordCountHive elementStat = {{TString("Sort"), 0}, {TString("Write!"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Sort"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write!"]);
+    }
+
+    Y_UNIT_TEST(ReferenceToKeyInSubselect) {
+        NYql::TAstParseResult res = SqlToYql("select b.key from (select a.key from plato.Input as a) as b;");
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(OrderByCastValue) {
+        NYql::TAstParseResult res = SqlToYql("select i.key, i.subkey from plato.Input as i order by cast(key as uint32) desc;");
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(GroupByCastValue) {
+        NYql::TAstParseResult res = SqlToYql("select count(1) from plato.Input as i group by cast(key as uint8);");
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(KeywordInSelectColumns) {
+        NYql::TAstParseResult res = SqlToYql("select in, s.check from (select 1 as in, \"test\" as check) as s;");
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(SelectAllGroupBy) {
+        NYql::TAstParseResult res = SqlToYql("select * from plato.Input group by subkey;");
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(CreateObjectWithFeatures) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; CREATE OBJECT secretId (TYPE SECRET) WITH (Key1=Value1, K2=V2);");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("'('\"K2\" '\"V2\") '('\"Key1\" '\"Value1\")"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("createObject"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0}, {TString("SECRET"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["SECRET"]);
+    }
+
+    Y_UNIT_TEST(CreateObjectIfNotExists) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; CREATE OBJECT IF NOT EXISTS secretId (TYPE SECRET) WITH (Key1=Value1, K2=V2);");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("createObjectIfNotExists"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0}, {TString("SECRET"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["SECRET"]);
+    }
+
+    Y_UNIT_TEST(CreateObjectWithFeaturesStrings) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; CREATE OBJECT secretId (TYPE SECRET) WITH (Key1=\"Value1\", K2='V2', K3=V3, K4='', K5=`aaa`, K6='a\\'aa');");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("'('\"K2\" '\"V2\") '('\"K3\" '\"V3\") '('\"K4\" '\"\") '('\"K5\" '\"aaa\") '('\"K6\" '\"a'aa\") '('\"Key1\" '\"Value1\")"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("createObject"));
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("Write"), 0}, {TString("SECRET"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+    }
+
+    Y_UNIT_TEST(UpsertObjectWithFeatures) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; UPSERT OBJECT secretId (TYPE SECRET) WITH (Key1=Value1, K2=V2);");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("'('\"K2\" '\"V2\") '('\"Key1\" '\"Value1\")"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("upsertObject"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0}, {TString("SECRET"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["SECRET"]);
+    }
+
+    Y_UNIT_TEST(CreateObjectWithFeaturesAndFlags) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; CREATE OBJECT secretId (TYPE SECRET) WITH (Key1=Value1, K2=V2, RECURSE);");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("'('\"Key1\" '\"Value1\") '('\"RECURSE\")"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("createObject"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0}, {TString("SECRET"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["SECRET"]);
+    }
+
+    Y_UNIT_TEST(Select1Type) {
+        NYql::TAstParseResult res = SqlToYql("SELECT 1 type;");
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(SelectTableType) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; SELECT * from T type;");
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(CreateObjectNoFeatures) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; CREATE OBJECT secretId (TYPE SECRET);");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_EQUAL(TString::npos, line.find("'features"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("createObject"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0}, {TString("SECRET"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["SECRET"]);
+    }
+
+    Y_UNIT_TEST(AlterObjectWithFeatures) {
+        NYql::TAstParseResult res = SqlToYql(
+            "USE plato;\n"
+            "declare $path as String;\n"
+            "ALTER OBJECT secretId (TYPE SECRET) SET (Key1=$path, K2=V2);"
+        );
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("'features"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("'\"Key1\" (EvaluateAtom \"$path\""));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("'\"K2\" '\"V2\""));
+
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("alterObject"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0}, {TString("SECRET"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["SECRET"]);
+    }
+
+    Y_UNIT_TEST(AlterObjectNoFeatures) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; ALTER OBJECT secretId (TYPE SECRET);");
+        UNIT_ASSERT(!res.Root);
+    }
+
+    Y_UNIT_TEST(DropObjectNoFeatures) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; DROP OBJECT secretId (TYPE SECRET);");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_EQUAL(TString::npos, line.find("'features"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("dropObject"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0}, {TString("SECRET"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["SECRET"]);
+    }
+
+    Y_UNIT_TEST(DropObjectWithFeatures) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; DROP OBJECT secretId (TYPE SECRET) WITH (A, B, C);");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("'features"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("dropObject"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0}, {TString("SECRET"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["SECRET"]);
+    }
+
+    Y_UNIT_TEST(DropObjectWithOneOption) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; DROP OBJECT secretId (TYPE SECRET) WITH OVERRIDE;");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("'features"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("'\"OVERRIDE\""));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("dropObject"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0}, {TString("SECRET"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["SECRET"]);
+    }
+
+    Y_UNIT_TEST(DropObjectIfExists) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; DROP OBJECT IF EXISTS secretId (TYPE SECRET);");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("dropObjectIfExists"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0}, {TString("SECRET"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["SECRET"]);
+    }
+
+    Y_UNIT_TEST(PrimaryKeyParseCorrect) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; CREATE TABLE tableName (Key Uint32, Subkey Int64, Value String, PRIMARY KEY (Key, Subkey));");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("\"Key\""));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("\"Subkey\""));
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("Write"), 0}, {TString("primarykey"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["primarykey"]);
+    }
+
+    Y_UNIT_TEST(CreateTableNonNullableYqlTypeAstCorrect) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; CREATE TABLE t (a int32 not null);");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write!") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos,
+                                           line.find(R"__((Write! world sink (Key '('tablescheme (String '"t"))) values '('('mode 'create) '('columns '('('"a" (DataType 'Int32) '('columnConstrains '('('not_null))) '())))))))__"));
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("Write!"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write!"]);
+    }
+
+    Y_UNIT_TEST(CreateTableNullableYqlTypeAstCorrect) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; CREATE TABLE t (a int32);");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write!") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos,
+                                           line.find(R"__((Write! world sink (Key '('tablescheme (String '"t"))) values '('('mode 'create) '('columns '('('"a" (AsOptionalType (DataType 'Int32)) '('columnConstrains '()) '()))))))__"));
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("Write!"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write!"]);
+    }
+
+    Y_UNIT_TEST(CreateTableNonNullablePgTypeAstCorrect) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; CREATE TABLE t (a pg_int4 not null);");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write!") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos,
+                                           line.find(R"__((Write! world sink (Key '('tablescheme (String '"t"))) values '('('mode 'create) '('columns '('('"a" (PgType '_int4) '('columnConstrains '('('not_null))) '())))))))__"));
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("Write!"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write!"]);
+    }
+
+    Y_UNIT_TEST(CreateTableNullablePgTypeAstCorrect) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; CREATE TABLE t (a pg_int4);");
+        UNIT_ASSERT(res.Root);
+
+            res.Root->PrettyPrintTo(Cout, PRETTY_FLAGS);
+
+            TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+                if (word == "Write!") {
+                    UNIT_ASSERT_VALUES_UNEQUAL(TString::npos,
+                                               line.find(R"__((Write! world sink (Key '('tablescheme (String '"t"))) values '('('mode 'create) '('columns '('('"a" (AsOptionalType (PgType '_int4)) '('columnConstrains '()) '()))))))__"));
+                }
+            };
+
+            TWordCountHive elementStat = {{TString("Write!"), 0}};
+            VerifyProgram(res, elementStat, verifyLine);
+
+            UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write!"]);
+    }
+
+    Y_UNIT_TEST(CreateTableNullPkColumnsAreAllowed) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; CREATE TABLE t (a int32, primary key(a));");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write!") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos,
+                                           line.find(R"__((Write! world sink (Key '('tablescheme (String '"t"))) values '('('mode 'create) '('columns '('('"a" (AsOptionalType (DataType 'Int32)) '('columnConstrains '()) '()))) '('primarykey '('"a")))))__"));
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("Write!"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write!"]);
+    }
+
+    Y_UNIT_TEST(CreateTableNotNullPkColumnsAreIdempotentAstCorrect) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; CREATE TABLE t (a int32 not null, primary key(a));");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write!") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos,
+                                           line.find(R"__((Write! world sink (Key '('tablescheme (String '"t"))) values '('('mode 'create) '('columns '('('"a" (DataType 'Int32) '('columnConstrains '('('not_null))) '()))) '('primarykey '('"a"))))))__"));
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("Write!"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write!"]);
+    }
+
+    Y_UNIT_TEST(CreateTableWithIfNotExists) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; CREATE TABLE IF NOT EXISTS t (a int32, primary key(a));");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write!") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos,
+                                           line.find(R"__((Write! world sink (Key '('tablescheme (String '"t"))) values '('('mode 'create_if_not_exists) '('columns '('('"a" (AsOptionalType (DataType 'Int32)) '('columnConstrains '()) '()))) '('primarykey '('"a")))))__"));
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("Write!"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write!"]);
+    }
+
+    Y_UNIT_TEST(CreateTempTable) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; CREATE TEMP TABLE t (a int32, primary key(a));");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write!") {
+                UNIT_ASSERT_VALUES_UNEQUAL_C(TString::npos,
+                                           line.find(R"__((Write! world sink (Key '('tablescheme (String '"t"))) values '('('mode 'create) '('columns '('('"a" (AsOptionalType (DataType 'Int32)) '('columnConstrains '()) '()))) '('primarykey '('"a")) '('temporary))))__"), line);
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("Write!"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write!"]);
+    }
+
+    Y_UNIT_TEST(CreateTemporaryTable) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; CREATE TEMPORARY TABLE t (a int32, primary key(a));");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write!") {
+                UNIT_ASSERT_VALUES_UNEQUAL_C(TString::npos,
+                                           line.find(R"__((Write! world sink (Key '('tablescheme (String '"t"))) values '('('mode 'create) '('columns '('('"a" (AsOptionalType (DataType 'Int32)) '('columnConstrains '()) '()))) '('primarykey '('"a")) '('temporary))))__"), line);
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("Write!"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write!"]);
+    }
+
+    Y_UNIT_TEST(CreateTableWithoutTypes) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; CREATE TABLE t (a, primary key(a));");
+        UNIT_ASSERT(!res.Root);
+    }
+
+    Y_UNIT_TEST(CreateTableAsSelectWithTypes) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; CREATE TABLE t (a int32, primary key(a)) AS SELECT * FROM ts;");
+        UNIT_ASSERT(!res.Root);
+    }
+
+    Y_UNIT_TEST(CreateTableAsSelect) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; CREATE TABLE t (a, b, primary key(a)) AS SELECT * FROM ts;");
+        UNIT_ASSERT_C(res.Root, res.Issues.ToString());
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write!") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos,
+                                           line.find(R"__((let world (Write! world sink (Key '('tablescheme (String '"t"))) values '('('mode 'create) '('columns '('('"a") '('"b"))) '('primarykey '('"a"))))))__"));
+            }
+            if (word == "Read!") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos,
+                                           line.find(R"__((Read! world (DataSource '"yt" '"plato") (MrTableConcat (Key '('table (String '"ts")))))__"));
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("Write!"), 0}, {TString("Read!"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write!"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Read!"]);
+    }
+
+    Y_UNIT_TEST(CreateTableAsSelectOnlyPrimary) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; CREATE TABLE t (primary key(a)) AS SELECT * FROM ts;");
+        UNIT_ASSERT_C(res.Root, res.Issues.ToString());
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write!") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos,
+                                           line.find(R"__((let world (Write! world sink (Key '('tablescheme (String '"t"))) values '('('mode 'create) '('columns '()) '('primarykey '('"a"))))))__"));
+            }
+            if (word == "Read!") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos,
+                                           line.find(R"__((Read! world (DataSource '"yt" '"plato") (MrTableConcat (Key '('table (String '"ts")))))__"));
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("Write!"), 0}, {TString("Read!"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write!"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Read!"]);
+    }
+
+    Y_UNIT_TEST(CreateTableAsValuesFail) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; CREATE TABLE t (a, primary key(a)) AS VALUES (1), (2);");
+        UNIT_ASSERT(!res.Root);
+    }
+
+    Y_UNIT_TEST(CreateTableDuplicatedPkColumnsFail) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; CREATE TABLE t (a int32 not null, primary key(a, a));");
+        UNIT_ASSERT(!res.Root);
+    }
+
+    Y_UNIT_TEST(DeleteFromTableByKey) {
+        NYql::TAstParseResult res = SqlToYql("delete from plato.Input where key = 200;", 10, "kikimr");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("('mode 'delete)"));
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("Write"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(DeleteFromTable) {
+        NYql::TAstParseResult res = SqlToYql("delete from plato.Input;", 10, "kikimr");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("('mode 'delete)"));
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("Write"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(DeleteFromTableOnValues) {
+        NYql::TAstParseResult res = SqlToYql("delete from plato.Input on (key) values (1);",
+            10, "kikimr");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("('mode 'delete_on)"));
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("Write"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(DeleteFromTableOnSelect) {
+        NYql::TAstParseResult res = SqlToYql(
+            "delete from plato.Input on select key from plato.Input where value > 0;", 10, "kikimr");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("('mode 'delete_on)"));
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("Write"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(UpdateByValues) {
+        NYql::TAstParseResult res = SqlToYql("update plato.Input set key = 777, value = 'cool' where key = 200;", 10, "kikimr");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("('mode 'update)"));
+            } else if (word == "AsStruct") {
+                const bool isKey = line.find("key") != TString::npos;
+                const bool isValue = line.find("value") != TString::npos;
+                UNIT_ASSERT(isKey || isValue);
+                if (isKey) {
+                    UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(Quote("777")));
+                } else if (isValue) {
+                    UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(Quote("cool")));
+                }
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("Write"), 0}, {TString("AsStruct"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["AsStruct"]);
+    }
+
+    Y_UNIT_TEST(UpdateByMultiValues) {
+        NYql::TAstParseResult res = SqlToYql("update plato.Input set (key, value, subkey) = ('2','ddd',':') where key = 200;", 10, "kikimr");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("('mode 'update)"));
+            } else if (word == "AsStruct") {
+                const bool isKey = line.find("key") != TString::npos;
+                const bool isSubkey = line.find("subkey") != TString::npos;
+                const bool isValue = line.find("value") != TString::npos;
+                UNIT_ASSERT(isKey || isSubkey || isValue);
+                if (isKey && !isSubkey) {
+                    UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(Quote("2")));
+                } else if (isSubkey) {
+                    UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(Quote(":")));
+                } else if (isValue) {
+                    UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(Quote("ddd")));
+                }
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("Write"), 0}, {TString("AsStruct"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["AsStruct"]);
+    }
+
+    Y_UNIT_TEST(UpdateBySelect) {
+        NYql::TAstParseResult res = SqlToYql("update plato.Input set (key, value, subkey) = (select key, value, subkey from plato.Input where key = 911) where key = 200;", 10, "kikimr");
+        UNIT_ASSERT(res.Root);
+
+        int lineIndex = 0;
+        int writeLineIndex = -1;
+        bool found = false;
+
+        TVerifyLineFunc verifyLine = [&lineIndex, &writeLineIndex, &found](const TString& word, const TString& line) {
+            if (word == "Write") {
+                writeLineIndex = lineIndex;
+                found = line.find("('mode 'update)") != TString::npos;
+            } else if (word == "mode") {
+                found |= lineIndex == writeLineIndex + 1 && line.find("('mode 'update)") != TString::npos;
+                UNIT_ASSERT(found);
+            }
+
+            ++lineIndex;
+        };
+
+        TWordCountHive elementStat = {{TString("Write"), 0}, {TString("mode"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(UpdateSelfModifyAll) {
+        NYql::TAstParseResult res = SqlToYql("update plato.Input set subkey = subkey + 's';", 10, "kikimr");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("('mode 'update)"));
+            } else if (word == "AsStruct") {
+                const bool isSubkey = line.find("subkey") != TString::npos;
+                UNIT_ASSERT(isSubkey);
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(Quote("subkey")));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(Quote("s")));
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("Write"), 0}, {TString("AsStruct"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["AsStruct"]);
+    }
+
+    Y_UNIT_TEST(UpdateOnValues) {
+        NYql::TAstParseResult res = SqlToYql("update plato.Input on (key, value) values (5, 'cool')", 10, "kikimr");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("('mode 'update_on)"));
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("Write"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(UpdateOnSelect) {
+        NYql::TAstParseResult res = SqlToYql(
+            "update plato.Input on select key, value + 1 as value from plato.Input", 10, "kikimr");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("('mode 'update_on)"));
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("Write"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(UnionAllTest) {
+        NYql::TAstParseResult res = SqlToYql("SELECT key FROM plato.Input UNION ALL select subkey FROM plato.Input;");
+        UNIT_ASSERT(res.Root);
+
+        TWordCountHive elementStat = {{TString("UnionAll"), 0}};
+        VerifyProgram(res, elementStat, {});
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["UnionAll"]);
+    }
+
+    Y_UNIT_TEST(UnionTest) {
+        NYql::TAstParseResult res = SqlToYql("SELECT key FROM plato.Input UNION select subkey FROM plato.Input;");
+        UNIT_ASSERT(res.Root);
+
+        TWordCountHive elementStat = {{TString("Union"), 0}};
+        VerifyProgram(res, elementStat, {});
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Union"]);
+    }
+
+    Y_UNIT_TEST(UnionAggregationTest) {
+        NYql::TAstParseResult res = SqlToYql(R"(
+            SELECT 1
+            UNION ALL
+                SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1
+            UNION
+                SELECT 1 UNION SELECT 1 UNION SELECT 1 UNION SELECT 1
+            UNION ALL
+                SELECT 1 UNION ALL SELECT 1 UNION ALL SELECT 1;
+        )");
+        UNIT_ASSERT(res.Root);
+
+        TWordCountHive elementStat = {{TString("Union"), 0}, {TString("UnionAll"), 0}};
+        VerifyProgram(res, elementStat, {});
+        UNIT_ASSERT_VALUES_EQUAL(2, elementStat["UnionAll"]);
+        UNIT_ASSERT_VALUES_EQUAL(3, elementStat["Union"]);
+    }
+
+    Y_UNIT_TEST(DeclareDecimalParameter) {
+        NYql::TAstParseResult res = SqlToYql("declare $value as Decimal(22,9); select $value as cnt;");
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(SimpleGroupBy) {
+        NYql::TAstParseResult res = SqlToYql("select count(1),z from plato.Input group by key as z order by z;");
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(EmptyColumnName0) {
+        /// Now it's parsed well and error occur on validate step like "4:31:Empty struct member name is not allowed" in "4:31:Function: AddMember"
+        NYql::TAstParseResult res = SqlToYql("insert into plato.Output (``, list1) values (0, AsList(0, 1, 2));");
+        /// Verify that parsed well without crash
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(KikimrRollback) {
+        NYql::TAstParseResult res = SqlToYql("use plato; select * from Input; rollback;", 10, "kikimr");
+        UNIT_ASSERT(res.Root);
+
+        TWordCountHive elementStat = {{TString("rollback"), 0}};
+        VerifyProgram(res, elementStat);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["rollback"]);
+    }
+
+    Y_UNIT_TEST(PragmaFile) {
+        NYql::TAstParseResult res = SqlToYql(R"(pragma file("HW", "sbr:181041334");)");
+        UNIT_ASSERT(res.Root);
+
+        TWordCountHive elementStat = {{TString(R"((let world (Configure! world (DataSource '"config") '"AddFileByUrl" '"HW" '"sbr:181041334")))"), 0}};
+        VerifyProgram(res, elementStat);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat.cbegin()->second);
+    }
+
+    Y_UNIT_TEST(DoNotCrashOnNamedInFilter) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; $all = ($table_name) -> { return true; }; SELECT * FROM FILTER(Input, $all)");
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(PragmasFileAndUdfOrder) {
+        NYql::TAstParseResult res = SqlToYql(R"(
+            PRAGMA file("libvideoplayers_udf.so", "https://proxy.sandbox.yandex-team.ru/235185290");
+            PRAGMA udf("libvideoplayers_udf.so");
+        )");
+        UNIT_ASSERT(res.Root);
+
+        const auto programm = GetPrettyPrint(res);
+        const auto file = programm.find("AddFileByUrl");
+        const auto udfs = programm.find("ImportUdfs");
+        UNIT_ASSERT(file < udfs);
+    }
+
+    Y_UNIT_TEST(ProcessUserType) {
+        NYql::TAstParseResult res = SqlToYql("process plato.Input using Kikimr::PushData(TableRows());", 1, TString(NYql::KikimrProviderName));
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Kikimr.PushData") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("TupleType"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("TypeOf"));
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("Kikimr.PushData"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Kikimr.PushData"]);
+    }
+
+    Y_UNIT_TEST(ProcessUserTypeAuth) {
+        NYql::TAstParseResult res = SqlToYql("process plato.Input using YDB::PushData(TableRows(), AsTuple('oauth', SecureParam('api:oauth')));", 1, TString(NYql::KikimrProviderName));
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "YDB.PushData") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("TupleType"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("TypeOf"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("api:oauth"));
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("YDB.PushData"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["YDB.PushData"]);
+    }
+
+    Y_UNIT_TEST(SelectStreamRtmr) {
+        NYql::TAstParseResult res = SqlToYql(
+            "USE plato; INSERT INTO Output SELECT STREAM key FROM Input;",
+            10, TString(NYql::RtmrProviderName));
+        UNIT_ASSERT(res.Root);
+
+        res = SqlToYql(
+            "USE plato; INSERT INTO Output SELECT key FROM Input;",
+            10, TString(NYql::RtmrProviderName));
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(SelectStreamRtmrJoinWithYt) {
+        NYql::TAstParseResult res = SqlToYql(
+            "USE plato; INSERT INTO Output SELECT STREAM key FROM Input LEFT JOIN hahn.ttt as t ON Input.key = t.Name;",
+            10, TString(NYql::RtmrProviderName));
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(SelectStreamNonRtmr) {
+        NYql::TAstParseResult res = SqlToYql(
+            "USE plato; INSERT INTO Output SELECT STREAM key FROM Input;",
+            10);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:31: Error: SELECT STREAM is unsupported for non-streaming sources\n");
+    }
+
+    Y_UNIT_TEST(GroupByHopRtmr) {
+        NYql::TAstParseResult res = SqlToYql(R"(
+            USE plato; INSERT INTO Output SELECT key, SUM(value) AS value FROM Input
+            GROUP BY key, HOP(subkey, "PT10S", "PT30S", "PT20S");
+        )", 10, TString(NYql::RtmrProviderName));
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(GroupByHopRtmrSubquery) {
+        // 'use plato' intentially avoided
+        NYql::TAstParseResult res = SqlToYql(R"(
+            SELECT COUNT(*) AS value FROM (SELECT * FROM plato.Input)
+            GROUP BY HOP(Data, "PT10S", "PT30S", "PT20S")
+        )", 10, TString(NYql::RtmrProviderName));
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(GroupByHopRtmrSubqueryBinding) {
+        NYql::TAstParseResult res = SqlToYql(R"(
+            USE plato;
+            $q = SELECT * FROM Input;
+            INSERT INTO Output SELECT STREAM * FROM (
+                SELECT COUNT(*) AS value FROM $q
+                GROUP BY HOP(Data, "PT10S", "PT30S", "PT20S")
+            );
+        )", 10, TString(NYql::RtmrProviderName));
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(GroupByNoHopRtmr) {
+        NYql::TAstParseResult res = SqlToYql(R"(
+            USE plato; INSERT INTO Output SELECT STREAM key, SUM(value) AS value FROM Input
+            GROUP BY key;
+        )", 10, TString(NYql::RtmrProviderName));
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:3:22: Error: Streaming group by query must have a hopping window specification.\n");
+    }
+
+    Y_UNIT_TEST(KikimrInserts) {
+         NYql::TAstParseResult res = SqlToYql(R"(
+            USE plato;
+            INSERT INTO Output SELECT key, value FROM Input;
+            INSERT OR ABORT INTO Output SELECT key, value FROM Input;
+            INSERT OR IGNORE INTO Output SELECT key, value FROM Input;
+            INSERT OR REVERT INTO Output SELECT key, value FROM Input;
+        )", 10, TString(NYql::KikimrProviderName));
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(WarnMissingIsBeforeNotNull) {
+        NYql::TAstParseResult res = SqlToYql("select 1 NOT NULL");
+        UNIT_ASSERT(res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:8: Warning: Missing IS keyword before NOT NULL, code: 4507\n");
+    }
+
+    Y_UNIT_TEST(Subqueries) {
+        NYql::TAstParseResult res = SqlToYql(R"(
+            USE plato;
+            $sq1 = (SELECT * FROM plato.Input);
+
+            $sq2 = SELECT * FROM plato.Input;
+
+            $squ1 = (
+                SELECT * FROM plato.Input
+                UNION ALL
+                SELECT * FROM plato.Input
+            );
+
+            $squ2 =
+                SELECT * FROM plato.Input
+                UNION ALL
+                SELECT * FROM plato.Input;
+
+            $squ3 = (
+                (SELECT * FROM plato.Input)
+                UNION ALL
+                (SELECT * FROM plato.Input)
+            );
+
+            SELECT * FROM $sq1;
+            SELECT * FROM $sq2;
+            SELECT * FROM $squ1;
+            SELECT * FROM $squ2;
+            SELECT * FROM $squ3;
+        )");
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(SubqueriesJoin) {
+        NYql::TAstParseResult res = SqlToYql(R"(
+            USE plato;
+
+            $left = SELECT * FROM plato.Input1 WHERE value != "BadValue";
+            $right = SELECT * FROM plato.Input2;
+
+            SELECT * FROM $left AS l
+            JOIN $right AS r
+            ON l.key == r.key;
+        )");
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(AnyInBackticksAsTableName) {
+        NYql::TAstParseResult res = SqlToYql("use plato; select * from `any`;");
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(AnyJoinForTableAndSubQuery) {
+        NYql::TAstParseResult res = SqlToYql(R"(
+            USE plato;
+
+            $r = SELECT * FROM plato.Input2;
+
+            SELECT * FROM ANY plato.Input1 AS l
+            LEFT JOIN ANY $r AS r
+            USING (key);
+        )");
+
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "EquiJoin") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("'('left 'any)"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("'('right 'any)"));
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("left"), 0}, {TString("right"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["left"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["right"]);
+    }
+
+    Y_UNIT_TEST(AnyJoinForTableAndTableSource) {
+        NYql::TAstParseResult res = SqlToYql(R"(
+            USE plato;
+
+            $r = AsList(
+                AsStruct("aaa" as key, "bbb" as subkey, "ccc" as value)
+            );
+
+            SELECT * FROM ANY plato.Input1 AS l
+            LEFT JOIN ANY AS_TABLE($r) AS r
+            USING (key);
+        )");
+
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "EquiJoin") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("'('left 'any)"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("'('right 'any)"));
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("left"), 0}, {TString("right"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["left"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["right"]);
+    }
+
+    Y_UNIT_TEST(AnyJoinNested) {
+        NYql::TAstParseResult res = SqlToYql(R"(
+            USE plato;
+
+            FROM ANY Input1 as a
+                JOIN Input2 as b ON a.key = b.key
+                LEFT JOIN ANY Input3 as c ON a.key = c.key
+                RIGHT JOIN ANY Input4 as d ON d.key = b.key
+                CROSS JOIN Input5
+            SELECT *;
+        )");
+
+        UNIT_ASSERT(res.Root);
+
+        TWordCountHive elementStat = {{TString("left"), 0}, {TString("right"), 0}};
+        VerifyProgram(res, elementStat);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["left"]);
+        UNIT_ASSERT_VALUES_EQUAL(2, elementStat["right"]);
+    }
+
+    Y_UNIT_TEST(InlineAction) {
+        NYql::TAstParseResult res = SqlToYql(
+            "do begin\n"
+            "  select 1\n"
+            "; end do\n");
+        UNIT_ASSERT(res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "");
+    }
+
+    Y_UNIT_TEST(FlattenByCorrelationName) {
+        UNIT_ASSERT(SqlToYql("select * from plato.Input as t flatten by t.x").IsOk());
+        UNIT_ASSERT(SqlToYql("select * from plato.Input as t flatten by t -- same as flatten by t.t").IsOk());
+    }
+
+    Y_UNIT_TEST(DiscoveryMode) {
+        UNIT_ASSERT(SqlToYqlWithMode("insert into plato.Output select * from plato.Input", NSQLTranslation::ESqlMode::DISCOVERY).IsOk());
+        UNIT_ASSERT(SqlToYqlWithMode("select * from plato.concat(Input1, Input2)", NSQLTranslation::ESqlMode::DISCOVERY).IsOk());
+        UNIT_ASSERT(SqlToYqlWithMode("select * from plato.each(AsList(\"Input1\", \"Input2\"))", NSQLTranslation::ESqlMode::DISCOVERY).IsOk());
+    }
+
+    Y_UNIT_TEST(CubeWithAutoGeneratedLikeColumnName) {
+        UNIT_ASSERT(SqlToYql("select key,subkey,group from plato.Input group by cube(key,subkey,group)").IsOk());
+    }
+
+    Y_UNIT_TEST(CubeWithAutoGeneratedLikeAlias) {
+        UNIT_ASSERT(SqlToYql("select key,subkey,group from plato.Input group by cube(key,subkey,value as group)").IsOk());
+    }
+
+    Y_UNIT_TEST(FilterCanBeUsedAsColumnIdOrBind) {
+        UNIT_ASSERT(SqlToYql("select filter from plato.Input").IsOk());
+        UNIT_ASSERT(SqlToYql("select 1 as filter").IsOk());
+        UNIT_ASSERT(SqlToYql("$filter = 1; select $filter").IsOk());
+    }
+
+    Y_UNIT_TEST(DuplicateSemicolonsAreAllowedBetweenTopLevelStatements) {
+        UNIT_ASSERT(SqlToYql(";;select 1; ; select 2;/*comment*/;select 3;;--comment\n;select 4;;").IsOk());
+    }
+
+    Y_UNIT_TEST(DuplicateAndMissingTrailingSemicolonsAreAllowedBetweenActionStatements) {
+        TString req =
+            "define action $action($b,$c) as\n"
+            "    ;;$d = $b + $c;\n"
+            "    select $b;\n"
+            "    select $c;;\n"
+            "    select $d,\n"
+            "end define;\n"
+            "\n"
+            "do $action(1,2);";
+        UNIT_ASSERT(SqlToYql(req).IsOk());
+    }
+
+    Y_UNIT_TEST(DuplicateAndMissingTrailingSemicolonsAreAllowedBetweenInlineActionStatements) {
+        TString req =
+            "do begin\n"
+            "    ;select 1,\n"
+            "end do;\n"
+            "evaluate for $i in AsList(1,2,3) do begin\n"
+            "    select $i;;\n"
+            "    select $i + $i;;\n"
+            "end do;";
+        UNIT_ASSERT(SqlToYql(req).IsOk());
+    }
+
+    Y_UNIT_TEST(DuplicateSemicolonsAreAllowedBetweenLambdaStatements) {
+        TString req =
+            "$x=1;\n"
+            "$foo = ($a, $b)->{\n"
+            "   ;;$v = $a + $b;\n"
+            "   $bar = ($c) -> {; return $c << $x};;\n"
+            "   return $bar($v);;\n"
+            "};\n"
+            "select $foo(1,2);";
+        UNIT_ASSERT(SqlToYql(req).IsOk());
+    }
+
+    Y_UNIT_TEST(StringLiteralWithEscapedBackslash) {
+        NYql::TAstParseResult res1 = SqlToYql(R"foo(SELECT 'a\\';)foo");
+        NYql::TAstParseResult res2 = SqlToYql(R"foo(SELECT "a\\";)foo");
+        UNIT_ASSERT(res1.Root);
+        UNIT_ASSERT(res2.Root);
+
+        TWordCountHive elementStat = {{TString("a\\"), 0}};
+
+        VerifyProgram(res1, elementStat);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["a\\"]);
+
+        VerifyProgram(res2, elementStat);
+        UNIT_ASSERT_VALUES_EQUAL(2, elementStat["a\\"]);
+    }
+
+    Y_UNIT_TEST(StringMultiLineLiteralWithEscapes) {
+        UNIT_ASSERT(SqlToYql("SELECT @@@foo@@@@bar@@@").IsOk());
+        UNIT_ASSERT(SqlToYql("SELECT @@@@@@@@@").IsOk());
+    }
+
+    Y_UNIT_TEST(StringMultiLineLiteralConsequitiveAt) {
+        UNIT_ASSERT(!SqlToYql("SELECT @").IsOk());
+        UNIT_ASSERT(!SqlToYql("SELECT @@").IsOk());
+        UNIT_ASSERT(!SqlToYql("SELECT @@@").IsOk());
+        UNIT_ASSERT( SqlToYql("SELECT @@@@").IsOk());
+        UNIT_ASSERT( SqlToYql("SELECT @@@@@").IsOk());
+
+        UNIT_ASSERT(!SqlToYql("SELECT @@@@@@").IsOk());
+        UNIT_ASSERT(!SqlToYql("SELECT @@@@@@@").IsOk());
+
+        UNIT_ASSERT( SqlToYql("SELECT @@@@@@@@").IsOk());
+        UNIT_ASSERT( SqlToYql("SELECT @@@@@@@@@").IsOk());
+        UNIT_ASSERT(!SqlToYql("SELECT @@@@@@@@@@").IsOk());
+    }
+
+    Y_UNIT_TEST(ConstnessForListDictSetCreate) {
+        auto req = "$foo = ($x, $y) -> (\"aaaa\");\n"
+                   "\n"
+                   "select\n"
+                   "    $foo(sum(key), ListCreate(String)),\n"
+                   "    $foo(sum(key), DictCreate(String, String)),\n"
+                   "    $foo(sum(key), SetCreate(String)),\n"
+                   "from (select 1 as key);";
+        UNIT_ASSERT(SqlToYql(req).IsOk());
+    }
+
+    Y_UNIT_TEST(CanUseEmptyTupleInWindowPartitionBy) {
+        auto req = "select sum(key) over w\n"
+                   "from plato.Input\n"
+                   "window w as (partition compact by (), (subkey), (), value || value as dvalue);";
+        UNIT_ASSERT(SqlToYql(req).IsOk());
+    }
+
+    Y_UNIT_TEST(DenyAnsiOrderByLimitLegacyMode) {
+        auto req = "pragma DisableAnsiOrderByLimitInUnionAll;\n"
+                   "use plato;\n"
+                   "\n"
+                   "select * from Input order by key limit 10\n"
+                   "union all\n"
+                   "select * from Input order by key limit 1;";
+
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:8: Error: DisableAnsiOrderByLimitInUnionAll pragma is deprecated and no longer supported\n");
+    }
+
+    Y_UNIT_TEST(ReduceUsingUdfWithShortcutsWorks) {
+        auto req = "use plato;\n"
+                   "\n"
+                   "$arg = 'foo';\n"
+                   "$func = XXX::YYY($arg);\n"
+                   "\n"
+                   "REDUCE Input ON key using $func(subkey);\n"
+                   "REDUCE Input ON key using $func(UUU::VVV(TableRow()));\n";
+        UNIT_ASSERT(SqlToYql(req).IsOk());
+        req = "use plato;\n"
+              "\n"
+              "$arg = 'foo';\n"
+              "$func = XXX::YYY($arg);\n"
+              "\n"
+              "REDUCE Input ON key using all $func(subkey);\n"
+              "REDUCE Input ON key using all $func(UUU::VVV(TableRow()));";
+        UNIT_ASSERT(SqlToYql(req).IsOk());
+    }
+
+    Y_UNIT_TEST(YsonDisableStrict) {
+        UNIT_ASSERT(SqlToYql("pragma yson.DisableStrict = \"false\";").IsOk());
+        UNIT_ASSERT(SqlToYql("pragma yson.DisableStrict;").IsOk());
+    }
+
+    Y_UNIT_TEST(YsonStrict) {
+        UNIT_ASSERT(SqlToYql("pragma yson.Strict = \"false\";").IsOk());
+        UNIT_ASSERT(SqlToYql("pragma yson.Strict;").IsOk());
+    }
+
+    Y_UNIT_TEST(JoinByTuple) {
+        auto req = "use plato;\n"
+                   "\n"
+                   "select * from T1 as a\n"
+                   "join T2 as b\n"
+                   "on AsTuple(a.key, a.subkey) = AsTuple(b.key, b.subkey);";
+        UNIT_ASSERT(SqlToYql(req).IsOk());
+    }
+
+    Y_UNIT_TEST(JoinByStruct) {
+        auto req = "use plato;\n"
+                   "\n"
+                   "select * from T1 as a\n"
+                   "join T2 as b\n"
+                   "on AsStruct(a.key as k, a.subkey as sk) = AsStruct(b.key as k, b.subkey as sk);";
+        UNIT_ASSERT(SqlToYql(req).IsOk());
+    }
+
+    Y_UNIT_TEST(JoinByUdf) {
+        auto req = "use plato;\n"
+                   "\n"
+                   "select a.align\n"
+                   "from T1 as a\n"
+                   "join T2 as b\n"
+                   "on Yson::SerializeJsonEncodeUtf8(a.align)=b.align;";
+        UNIT_ASSERT(SqlToYql(req).IsOk());
+    }
+
+    Y_UNIT_TEST(EscapedIdentifierAsLambdaArg) {
+        auto req = "$f = ($`foo bar`, $x) -> { return $`foo bar` + $x; };\n"
+                   "\n"
+                   "select $f(1, 2);";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(res.Root);
+        const auto programm = GetPrettyPrint(res);
+        auto expected = "(lambda '(\"$foo bar\" \"$x\")";
+        UNIT_ASSERT(programm.find(expected) != TString::npos);
+    }
+
+    Y_UNIT_TEST(UdfSyntaxSugarOnlyCallable) {
+        auto req = "SELECT Udf(DateTime::FromString)('2022-01-01');";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(res.Root);
+        const auto programm = GetPrettyPrint(res);
+        auto expected = "(SqlCall '\"DateTime.FromString\" '((PositionalArgs (String '\"2022-01-01\")) (AsStruct)) (TupleType (TypeOf '((String '\"2022-01-01\"))) (TypeOf (AsStruct)) (TupleType)))";
+        UNIT_ASSERT(programm.find(expected) != TString::npos);
+    }
+
+    Y_UNIT_TEST(UdfSyntaxSugarTypeNoRun) {
+        auto req = "SELECT Udf(DateTime::FromString, String, Tuple<Int32, Float>, 'foo' as TypeConfig)('2022-01-01');";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(res.Root);
+        const auto programm = GetPrettyPrint(res);
+        auto expected = "(SqlCall '\"DateTime.FromString\" '((PositionalArgs (String '\"2022-01-01\")) (AsStruct)) (TupleType (TypeOf '((String '\"2022-01-01\"))) (TypeOf (AsStruct)) (TupleType (DataType 'String) (TupleType (DataType 'Int32) (DataType 'Float)))) '\"foo\")";
+        UNIT_ASSERT(programm.find(expected) != TString::npos);
+    }
+
+    Y_UNIT_TEST(UdfSyntaxSugarRunNoType) {
+        auto req = "SELECT Udf(DateTime::FromString, String, Tuple<Int32, Float>, Void() as RunConfig)('2022-01-01');";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(res.Root);
+        const auto programm = GetPrettyPrint(res);
+        auto expected = "(SqlCall '\"DateTime.FromString\" '((PositionalArgs (String '\"2022-01-01\")) (AsStruct)) (TupleType (TypeOf '((String '\"2022-01-01\"))) (TypeOf (AsStruct)) (TupleType (DataType 'String) (TupleType (DataType 'Int32) (DataType 'Float)))) '\"\" (Void))";
+        UNIT_ASSERT(programm.find(expected) != TString::npos);
+    }
+
+    Y_UNIT_TEST(UdfSyntaxSugarFullTest) {
+        auto req = "SELECT Udf(DateTime::FromString, String, Tuple<Int32, Float>, 'foo' as TypeConfig, Void() As RunConfig)('2022-01-01');";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(res.Root);
+        const auto programm = GetPrettyPrint(res);
+        auto expected = "(SqlCall '\"DateTime.FromString\" '((PositionalArgs (String '\"2022-01-01\")) (AsStruct)) (TupleType (TypeOf '((String '\"2022-01-01\"))) (TypeOf (AsStruct)) (TupleType (DataType 'String) (TupleType (DataType 'Int32) (DataType 'Float)))) '\"foo\" (Void))";
+        UNIT_ASSERT(programm.find(expected) != TString::npos);
+    }
+
+    Y_UNIT_TEST(UdfSyntaxSugarOtherRunConfigs) {
+        auto req = "SELECT Udf(DateTime::FromString, String, Tuple<Int32, Float>, 'foo' as TypeConfig, '55' As RunConfig)('2022-01-01');";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(res.Root);
+        const auto programm = GetPrettyPrint(res);
+        auto expected = "(SqlCall '\"DateTime.FromString\" '((PositionalArgs (String '\"2022-01-01\")) (AsStruct)) (TupleType (TypeOf '((String '\"2022-01-01\"))) (TypeOf (AsStruct)) (TupleType (DataType 'String) (TupleType (DataType 'Int32) (DataType 'Float)))) '\"foo\" (String '\"55\"))";
+        UNIT_ASSERT(programm.find(expected) != TString::npos);
+    }
+
+    Y_UNIT_TEST(UdfSyntaxSugarOtherRunConfigs2) {
+        auto req = "SELECT Udf(DateTime::FromString, String, Tuple<Int32, Float>, 'foo' as TypeConfig, AsTuple(32, 'no', AsStruct(1e-9 As SomeFloat)) As RunConfig)('2022-01-01');";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(res.Root);
+        const auto programm = GetPrettyPrint(res);
+        auto expected = "(SqlCall '\"DateTime.FromString\" '((PositionalArgs (String '\"2022-01-01\")) (AsStruct)) (TupleType (TypeOf '((String '\"2022-01-01\"))) (TypeOf (AsStruct)) (TupleType (DataType 'String) (TupleType (DataType 'Int32) (DataType 'Float)))) '\"foo\" '((Int32 '\"32\") (String '\"no\") (AsStruct '('\"SomeFloat\" (Double '\"1e-9\")))))";
+        UNIT_ASSERT(programm.find(expected) != TString::npos);
+    }
+
+    Y_UNIT_TEST(UdfSyntaxSugarOptional) {
+        auto req = "SELECT Udf(DateTime::FromString, String?, Int32??, Tuple<Int32, Float>, \"foo\" as TypeConfig, Void() As RunConfig)(\"2022-01-01\");";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(res.Root);
+        const auto programm = GetPrettyPrint(res);
+        auto expected = "(SqlCall '\"DateTime.FromString\" '((PositionalArgs (String '\"2022-01-01\")) (AsStruct)) (TupleType (TypeOf '((String '\"2022-01-01\"))) (TypeOf (AsStruct)) (TupleType (OptionalType (DataType 'String)) (OptionalType (OptionalType (DataType 'Int32))) (TupleType (DataType 'Int32) (DataType 'Float)))) '\"foo\" (Void))";
+        UNIT_ASSERT(programm.find(expected) != TString::npos);
+    }
+
+    Y_UNIT_TEST(CompactionPolicyParseCorrect) {
+        NYql::TAstParseResult res = SqlToYql(
+            R"( USE plato;
+                CREATE TABLE tableName (Key Uint32, Value String, PRIMARY KEY (Key))
+                WITH ( COMPACTION_POLICY = "SomeCompactionPreset" );)"
+        );
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("compactionPolicy"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("SomeCompactionPreset"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(AutoPartitioningBySizeParseCorrect) {
+        NYql::TAstParseResult res = SqlToYql(
+            R"( USE plato;
+                CREATE TABLE tableName (Key Uint32, Value String, PRIMARY KEY (Key))
+                WITH ( AUTO_PARTITIONING_BY_SIZE = ENABLED );)"
+        );
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("autoPartitioningBySize"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("ENABLED"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(UniformPartitionsParseCorrect) {
+        NYql::TAstParseResult res = SqlToYql(
+            R"( USE plato;
+                CREATE TABLE tableName (Key Uint32, Value String, PRIMARY KEY (Key))
+                WITH ( UNIFORM_PARTITIONS = 16 );)"
+        );
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("uniformPartitions"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("16"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(DateTimeTtlParseCorrect) {
+        NYql::TAstParseResult res = SqlToYql(
+            R"( USE plato;
+                CREATE TABLE tableName (Key Uint32, CreatedAt Timestamp, PRIMARY KEY (Key))
+                WITH (TTL = Interval("P1D") On CreatedAt);)"
+        );
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("setTtlSettings"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("expireAfter"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("86400000"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(IntTtlParseCorrect) {
+        NYql::TAstParseResult res = SqlToYql(
+            R"( USE plato;
+                CREATE TABLE tableName (Key Uint32, CreatedAt Uint32, PRIMARY KEY (Key))
+                WITH (TTL = Interval("P1D") On CreatedAt AS SECONDS);)"
+        );
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("setTtlSettings"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("expireAfter"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("86400000"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("columnUnit"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("seconds"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(TieringParseCorrect) {
+        NYql::TAstParseResult res = SqlToYql(
+            R"( USE plato;
+                CREATE TABLE tableName (Key Uint32, Value String, PRIMARY KEY (Key))
+                WITH ( TIERING = 'my_tiering' );)"
+        );
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("tiering"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("my_tiering"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(StoreExternalBlobsParseCorrect) {
+        NYql::TAstParseResult res = SqlToYql(
+            R"( USE plato;
+                CREATE TABLE tableName (Key Uint32, Value String, PRIMARY KEY (Key))
+                WITH ( STORE_EXTERNAL_BLOBS = ENABLED );)"
+        );
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("storeExternalBlobs"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("ENABLED"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(DefaultValueColumn2) {
+        auto res = SqlToYql(R"( use plato;
+            $lambda = () -> {
+                RETURN CAST(RandomUuid(2) as String)
+            };
+
+            CREATE TABLE tableName (
+                Key Uint32 DEFAULT RandomNumber(1),
+                Value String DEFAULT $lambda,
+                PRIMARY KEY (Key)
+            );
+        )");
+
+        UNIT_ASSERT_C(res.Root, Err2Str(res));
+
+        const auto program = GetPrettyPrint(res);
+
+        UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, program.find("RandomNumber"));
+        UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, program.find("RandomUuid"));
+        UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, program.find("columnConstrains"));
+        UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, program.find("columnConstrains"));
+        UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, program.find("Write"));
+
+#if 0
+        Cerr << program << Endl;
+#endif
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(DefaultValueColumn3) {
+        auto res = SqlToYql(R"( use plato;
+
+            CREATE TABLE tableName (
+                database_id Utf8,
+                cloud_id Utf8,
+                global_id Utf8 DEFAULT database_id || "=====",
+                PRIMARY KEY (database_id)
+            );
+        )");
+
+        UNIT_ASSERT_VALUES_EQUAL(Err2Str(res), "<main>:6:40: Error: Column reference \"database_id\" is not allowed in current scope\n");
+        UNIT_ASSERT(!res.Root);
+    }
+
+    Y_UNIT_TEST(DefaultValueColumn) {
+        auto res = SqlToYql(R"( use plato;
+            CREATE TABLE tableName (
+                Key Uint32 FAMILY cold DEFAULT 5,
+                Value String FAMILY default DEFAULT "empty",
+                PRIMARY KEY (Key),
+                FAMILY default (
+                     DATA = "test",
+                     COMPRESSION = "lz4"
+                ),
+                FAMILY cold (
+                     DATA = "test",
+                     COMPRESSION = "off"
+                )
+            );
+        )");
+
+        UNIT_ASSERT_C(res.Root, Err2Str(res));
+
+#if 0
+        const auto program = GetPrettyPrint(res);
+        Cerr << program << Endl;
+#endif
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("default"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("columnConstrains"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("columnFamilies"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(ChangefeedParseCorrect) {
+        auto res = SqlToYql(R"( USE plato;
+            CREATE TABLE tableName (
+                Key Uint32, PRIMARY KEY (Key),
+                CHANGEFEED feedName WITH (
+                    MODE = 'KEYS_ONLY',
+                    FORMAT = 'json',
+                    INITIAL_SCAN = TRUE,
+                    VIRTUAL_TIMESTAMPS = FALSE,
+                    RESOLVED_TIMESTAMPS = Interval("PT1S"),
+                    RETENTION_PERIOD = Interval("P1D"),
+                    TOPIC_MIN_ACTIVE_PARTITIONS = 10,
+                    AWS_REGION = 'aws:region'
+                )
+            );
+        )");
+        UNIT_ASSERT_C(res.Root, Err2Str(res));
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("changefeed"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("mode"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("KEYS_ONLY"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("format"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("json"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("initial_scan"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("true"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("virtual_timestamps"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("false"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("resolved_timestamps"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("retention_period"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("topic_min_active_partitions"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("aws_region"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("aws:region"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(CloneForAsTableWorksWithCube) {
+        UNIT_ASSERT(SqlToYql("SELECT * FROM AS_TABLE([<|k1:1, k2:1|>]) GROUP BY CUBE(k1, k2);").IsOk());
+    }
+
+    Y_UNIT_TEST(WindowPartitionByColumnProperlyEscaped) {
+        NYql::TAstParseResult res = SqlToYql("SELECT SUM(key) OVER w FROM plato.Input WINDOW w AS (PARTITION BY `column with space`);");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "CalcOverWindow") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("\"column with space\""));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("CalcOverWindow"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["CalcOverWindow"]);
+    }
+
+    Y_UNIT_TEST(WindowPartitionByExpressionWithoutAliasesAreAllowed) {
+        NYql::TAstParseResult res = SqlToYql("SELECT SUM(key) OVER w FROM plato.Input as i WINDOW w AS (PARTITION BY ii.subkey);");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "AddMember") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("AddMember row 'group_w_0 (SqlAccess 'struct (Member row '\"ii\")"));
+            }
+            if (word == "CalcOverWindow") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("CalcOverWindow core '('\"group_w_0\")"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("CalcOverWindow"), 0}, {TString("AddMember"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["CalcOverWindow"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["AddMember"]);
+    }
+
+    Y_UNIT_TEST(PqReadByAfterUse) {
+        ExpectFailWithError("use plato; pragma PqReadBy='plato2';",
+            "<main>:1:28: Error: Cluster in PqReadPqBy pragma differs from cluster specified in USE statement: plato2 != plato\n");
+
+        UNIT_ASSERT(SqlToYql("pragma PqReadBy='plato2';").IsOk());
+        UNIT_ASSERT(SqlToYql("pragma PqReadBy='plato2'; use plato;").IsOk());
+        UNIT_ASSERT(SqlToYql("$x='plato'; use rtmr:$x; pragma PqReadBy='plato2';").IsOk());
+        UNIT_ASSERT(SqlToYql("use plato; pragma PqReadBy='dq';").IsOk());
+    }
+
+    Y_UNIT_TEST(MrObject) {
+        NYql::TAstParseResult res = SqlToYql(
+            "declare $path as String;\n"
+            "select * from plato.object($path, `format`, \"comp\" || \"ression\" as compression, 1 as bar) with schema (Int32 as y, String as x)"
+        );
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "MrObject") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos,
+                    line.find(R"__((MrObject (EvaluateAtom "$path") '"format" '('('"compression" (Concat (String '"comp") (String '"ression"))) '('"bar" (Int32 '"1")))))__"));
+            } else if (word == "userschema") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos,
+                    line.find(R"__('('('"userschema" (StructType '('"y" (DataType 'Int32)) '('"x" (DataType 'String))) '('"y" '"x"))))__"));
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("MrObject"), 0}, {TString("userschema"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["MrObject"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["userschema"]);
+    }
+
+    Y_UNIT_TEST(TableBindings) {
+        NSQLTranslation::TTranslationSettings settings = GetSettingsWithS3Binding("foo");
+        NYql::TAstParseResult res = SqlToYqlWithSettings(
+            "select * from bindings.foo",
+            settings
+        );
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "MrObject") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos,
+                                           line.find(R"__((MrTableConcat (Key '('table (String '"path")))) (Void) '('('"bar" '"1") '('"compression" '"ccompression") '('"format" '"format") '('"partitionedby" '"key" '"subkey") '('"userschema" (SqlTypeFromYson)__"));
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("MrTableConcat"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["MrTableConcat"]);
+
+        settings.DefaultCluster = "plato";
+        settings.BindingsMode = NSQLTranslation::EBindingsMode::DISABLED;
+        res = SqlToYqlWithSettings(
+            "select * from bindings.foo",
+            settings
+        );
+        UNIT_ASSERT_VALUES_EQUAL(Err2Str(res), "<main>:1:15: Error: Please remove 'bindings.' from your query, the support for this syntax has ended, code: 4601\n");
+        UNIT_ASSERT(!res.Root);
+
+        settings.BindingsMode = NSQLTranslation::EBindingsMode::DROP;
+        res = SqlToYqlWithSettings(
+            "select * from bindings.foo",
+            settings
+        );
+
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine2 = [](const TString& word, const TString& line) {
+            if (word == "MrTableConcat") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos,
+                                           line.find(R"__((MrTableConcat (Key '('table (String '"foo")))) (Void) '())))__"));
+            }
+        };
+
+        TWordCountHive elementStat2 = {{TString("MrTableConcat"), 0}};
+        VerifyProgram(res, elementStat2, verifyLine2);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat2["MrTableConcat"]);
+
+        settings.BindingsMode = NSQLTranslation::EBindingsMode::DROP_WITH_WARNING;
+        res = SqlToYqlWithSettings(
+            "select * from bindings.foo",
+            settings
+        );
+        UNIT_ASSERT_VALUES_EQUAL(Err2Str(res), "<main>:1:15: Warning: Please remove 'bindings.' from your query, the support for this syntax will be dropped soon, code: 4538\n");
+        UNIT_ASSERT(res.Root);
+
+        TWordCountHive elementStat3 = {{TString("MrTableConcat"), 0}};
+        VerifyProgram(res, elementStat3, verifyLine2);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat3["MrTableConcat"]);
+    }
+
+    Y_UNIT_TEST(TableBindingsWithInsert) {
+        NSQLTranslation::TTranslationSettings settings = GetSettingsWithS3Binding("foo");
+        NYql::TAstParseResult res = SqlToYqlWithSettings(
+            "insert into bindings.foo with truncate (x, y) values (1, 2);",
+            settings
+            );
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write!") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos,
+                                           line.find(R"__((Write! world sink (Key '('table (String '"path"))) values '('('"bar" '"1") '('"compression" '"ccompression") '('"format" '"format") '('"partitionedby" '"key" '"subkey") '('"userschema" (SqlTypeFromYson)__"));
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("Write!"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write!"]);
+
+        settings.DefaultCluster = "plato";
+        settings.BindingsMode = NSQLTranslation::EBindingsMode::DISABLED;
+        res = SqlToYqlWithSettings(
+            "insert into bindings.foo with truncate (x, y) values (1, 2);",
+            settings
+        );
+        UNIT_ASSERT_VALUES_EQUAL(Err2Str(res), "<main>:1:13: Error: Please remove 'bindings.' from your query, the support for this syntax has ended, code: 4601\n");
+        UNIT_ASSERT(!res.Root);
+
+        settings.BindingsMode = NSQLTranslation::EBindingsMode::DROP;
+        res = SqlToYqlWithSettings(
+            "insert into bindings.foo with truncate (x, y) values (1, 2);",
+            settings
+        );
+        UNIT_ASSERT_VALUES_EQUAL(Err2Str(res), "");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine2 = [](const TString& word, const TString& line) {
+            if (word == "Write!") {
+                //UNIT_ASSERT_VALUES_EQUAL(line, "");
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos,
+                                           line.find(R"__((Write! world sink (Key '('table (String '"foo"))) values '('('mode 'renew)))__"));
+            }
+        };
+
+        TWordCountHive elementStat2 = {{TString("Write!"), 0}};
+        VerifyProgram(res, elementStat2, verifyLine2);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat2["Write!"]);
+
+        settings.BindingsMode = NSQLTranslation::EBindingsMode::DROP_WITH_WARNING;
+        res = SqlToYqlWithSettings(
+            "insert into bindings.foo with truncate (x, y) values (1, 2);",
+            settings
+        );
+        UNIT_ASSERT_VALUES_EQUAL(Err2Str(res), "<main>:1:13: Warning: Please remove 'bindings.' from your query, the support for this syntax will be dropped soon, code: 4538\n");
+        UNIT_ASSERT(res.Root);
+
+        TWordCountHive elementStat3 = {{TString("Write!"), 0}};
+        VerifyProgram(res, elementStat3, verifyLine2);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat3["Write!"]);
+    }
+
+    Y_UNIT_TEST(TrailingCommaInWithout) {
+        UNIT_ASSERT(SqlToYql("SELECT * WITHOUT stream, FROM plato.Input").IsOk());
+        UNIT_ASSERT(SqlToYql("SELECT a.* WITHOUT a.intersect, FROM plato.Input AS a").IsOk());
+        UNIT_ASSERT(SqlToYql("SELECT a.* WITHOUT col1, col2, a.col3, FROM plato.Input AS a").IsOk());
+    }
+
+    Y_UNIT_TEST(NoStackOverflowOnBigCaseStatement) {
+        TStringBuilder req;
+        req << "select case 1 + 123";
+        for (size_t i = 0; i < 20000; ++i)  {
+            req << " when " << i << " then " << i + 1;
+        }
+        req << " else 100500 end;";
+        UNIT_ASSERT(SqlToYql(req).IsOk());
+    }
+
+    Y_UNIT_TEST(CollectPreaggregatedInListLiteral) {
+        UNIT_ASSERT(SqlToYql("SELECT [COUNT(DISTINCT a+b)] FROM plato.Input").IsOk());
+    }
+
+    Y_UNIT_TEST(SmartParenInGroupByClause) {
+        UNIT_ASSERT(SqlToYql("SELECT * FROM plato.Input GROUP BY (k, v)").IsOk());
+    }
+
+    Y_UNIT_TEST(AlterTableRenameToIsCorrect) {
+        UNIT_ASSERT(SqlToYql("USE plato; ALTER TABLE table RENAME TO moved").IsOk());
+    }
+
+    Y_UNIT_TEST(AlterTableAddDropColumnIsCorrect) {
+        UNIT_ASSERT(SqlToYql("USE plato; ALTER TABLE table ADD COLUMN addc uint64, DROP COLUMN dropc, ADD addagain uint64").IsOk());
+    }
+
+    Y_UNIT_TEST(AlterTableSetTTLIsCorrect) {
+        UNIT_ASSERT(SqlToYql("USE plato; ALTER TABLE table SET (TTL = Interval(\"PT3H\") ON column)").IsOk());
+        UNIT_ASSERT(SqlToYql("USE plato; ALTER TABLE table SET (TTL = Interval(\"PT3H\") ON column AS SECONDS)").IsOk());
+    }
+
+    Y_UNIT_TEST(AlterTableSetTieringIsCorrect) {
+        UNIT_ASSERT(SqlToYql("USE plato; ALTER TABLE table SET (TIERING = 'my_tiering')").IsOk());
+    }
+
+    Y_UNIT_TEST(AlterTableAddChangefeedIsCorrect) {
+        UNIT_ASSERT(SqlToYql("USE plato; ALTER TABLE table ADD CHANGEFEED feed WITH (MODE = 'UPDATES', FORMAT = 'json')").IsOk());
+    }
+
+    Y_UNIT_TEST(AlterTableAlterChangefeedIsCorrect) {
+        UNIT_ASSERT(SqlToYql("USE plato; ALTER TABLE table ALTER CHANGEFEED feed DISABLE").IsOk());
+        ExpectFailWithError("USE plato; ALTER TABLE table ALTER CHANGEFEED feed SET (FORMAT = 'proto');",
+            "<main>:1:57: Error: FORMAT alter is not supported\n");
+    }
+
+    Y_UNIT_TEST(AlterTableDropChangefeedIsCorrect) {
+        UNIT_ASSERT(SqlToYql("USE plato; ALTER TABLE table DROP CHANGEFEED feed").IsOk());
+    }
+
+    Y_UNIT_TEST(AlterTableSetPartitioningIsCorrect) {
+        UNIT_ASSERT(SqlToYql("USE plato; ALTER TABLE table SET (AUTO_PARTITIONING_BY_SIZE = DISABLED)").IsOk());
+    }
+
+    Y_UNIT_TEST(AlterTableAddIndexWithIsNotSupported) {
+        ExpectFailWithError("USE plato; ALTER TABLE table ADD INDEX idx GLOBAL ON (col) WITH (a=b)",
+            "<main>:1:40: Error: with: alternative is not implemented yet: \n");
+    }
+
+    Y_UNIT_TEST(AlterTableAddIndexLocalIsNotSupported) {
+        ExpectFailWithError("USE plato; ALTER TABLE table ADD INDEX idx LOCAL ON (col)",
+            "<main>:1:40: Error: local: alternative is not implemented yet: \n");
+    }
+
+    Y_UNIT_TEST(CreateTableAddIndexVector) {
+        const auto result = SqlToYql(R"(USE plato;
+            CREATE TABLE table (
+                pk INT32 NOT NULL,
+                col String, 
+                INDEX idx GLOBAL USING vector_kmeans_tree 
+                    ON (col) COVER (col)
+                    WITH (distance=cosine, vector_type=float, vector_dimension=1024,),
+                PRIMARY KEY (pk))
+                )");
+        UNIT_ASSERT_C(result.IsOk(), result.Issues.ToString());
+    }
+
+    Y_UNIT_TEST(AlterTableAddIndexVector) {
+        const auto result = SqlToYql(R"(USE plato; 
+            ALTER TABLE table ADD INDEX idx 
+                GLOBAL USING vector_kmeans_tree 
+                ON (col) COVER (col)
+                WITH (distance=cosine, vector_type="float", vector_dimension=1024) 
+                )");
+        UNIT_ASSERT_C(result.IsOk(), result.Issues.ToString());
+    }
+
+    Y_UNIT_TEST(AlterTableAddIndexUnknownSubtype) {
+        ExpectFailWithError("USE plato; ALTER TABLE table ADD INDEX idx GLOBAL USING unknown ON (col)",
+            "<main>:1:57: Error: UNKNOWN index subtype is not supported\n");
+    }
+
+    Y_UNIT_TEST(AlterTableAddIndexMissedParameter) {
+        ExpectFailWithError(R"(USE plato; 
+            ALTER TABLE table ADD INDEX idx 
+                GLOBAL USING vector_kmeans_tree 
+                ON (col)
+                WITH (distance=cosine, vector_type=float) 
+                )",
+            "<main>:5:52: Error: vector_dimension should be set\n");
+    }
+
+    Y_UNIT_TEST(AlterTableAlterIndexSetPartitioningIsCorrect) {
+        const auto result = SqlToYql("USE plato; ALTER TABLE table ALTER INDEX index SET AUTO_PARTITIONING_MIN_PARTITIONS_COUNT 10");
+        UNIT_ASSERT_C(result.IsOk(), result.Issues.ToString());
+    }
+
+    Y_UNIT_TEST(AlterTableAlterIndexSetMultiplePartitioningSettings) {
+        const auto result = SqlToYql("USE plato; ALTER TABLE table ALTER INDEX index SET "
+            "(AUTO_PARTITIONING_BY_LOAD = ENABLED, AUTO_PARTITIONING_MIN_PARTITIONS_COUNT = 10)"
+        );
+        UNIT_ASSERT_C(result.IsOk(), result.Issues.ToString());
+    }
+
+    Y_UNIT_TEST(AlterTableAlterIndexResetPartitioningIsNotSupported) {
+        ExpectFailWithError("USE plato; ALTER TABLE table ALTER INDEX index RESET (AUTO_PARTITIONING_MIN_PARTITIONS_COUNT)",
+            "<main>:1:55: Error: AUTO_PARTITIONING_MIN_PARTITIONS_COUNT reset is not supported\n"
+        );
+    }
+
+    Y_UNIT_TEST(AlterTableAlterColumnDropNotNullAstCorrect) {
+        auto reqSetNull = SqlToYql(R"(
+            USE plato;
+            CREATE TABLE tableName (
+                id Uint32,
+                val Uint32 NOT NULL,
+                PRIMARY KEY (id)
+            );
+
+            COMMIT;
+            ALTER TABLE tableName ALTER COLUMN val DROP NOT NULL;
+        )");
+
+        UNIT_ASSERT(reqSetNull.IsOk());
+        UNIT_ASSERT(reqSetNull.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            Y_UNUSED(word);
+
+            UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(
+                R"(let world (Write! world sink (Key '('tablescheme (String '"tableName"))) (Void) '('('mode 'alter) '('actions '('('alterColumns '('('"val" '('changeColumnConstraints '('('drop_not_null)))))))))))"
+            ));
+        };
+
+        TWordCountHive elementStat({TString("\'mode \'alter")});
+        VerifyProgram(reqSetNull, elementStat, verifyLine);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["\'mode \'alter"]);
+    }
+
+    Y_UNIT_TEST(OptionalAliases) {
+        UNIT_ASSERT(SqlToYql("USE plato; SELECT foo FROM (SELECT key foo FROM Input);").IsOk());
+        UNIT_ASSERT(SqlToYql("USE plato; SELECT a.x FROM Input1 a JOIN Input2 b ON a.key = b.key;").IsOk());
+        UNIT_ASSERT(SqlToYql("USE plato; SELECT a.x FROM (VALUES (1,2), (3,4)) a(x,key) JOIN Input b ON a.key = b.key;").IsOk());
+    }
+
+    Y_UNIT_TEST(TableNameConstness) {
+        UNIT_ASSERT(SqlToYql("USE plato; $path = 'foo'; SELECT TableName($path), count(*) FROM Input;").IsOk());
+        UNIT_ASSERT(SqlToYql("$path = 'foo'; SELECT TableName($path, 'yt'), count(*) FROM plato.Input;").IsOk());
+        ExpectFailWithError("USE plato; SELECT TableName(), count(*) FROM plato.Input;",
+            "<main>:1:19: Error: Expression has to be an aggregation function or key column, because aggregation is used elsewhere in this subquery\n");
+    }
+
+    Y_UNIT_TEST(UseShouldWorkAsColumnName) {
+        UNIT_ASSERT(SqlToYql("select use from (select 1 as use);").IsOk());
+    }
+
+    Y_UNIT_TEST(TrueFalseWorkAfterDollar) {
+        UNIT_ASSERT(SqlToYql("$ true = false; SELECT $ true or false;").IsOk());
+        UNIT_ASSERT(SqlToYql("$False = 0; SELECT $False;").IsOk());
+    }
+
+    Y_UNIT_TEST(WithSchemaEquals) {
+        UNIT_ASSERT(SqlToYql("select * from plato.T with schema Struct<a:Int32, b:String>;").IsOk());
+        UNIT_ASSERT(SqlToYql("select * from plato.T with columns = Struct<a:Int32, b:String>;").IsOk());
+    }
+
+    Y_UNIT_TEST(WithNonStructSchemaS3) {
+        NSQLTranslation::TTranslationSettings settings;
+        settings.ClusterMapping["s3bucket"] = NYql::S3ProviderName;
+        UNIT_ASSERT(SqlToYql("select * from s3bucket.`foo` with schema (col1 Int32, String as col2, Int64 as col3);", settings).IsOk());
+    }
+
+    Y_UNIT_TEST(AllowNestedTuplesInGroupBy) {
+        NYql::TAstParseResult res = SqlToYql("select count(*) from plato.Input group by 1 + (x, y, z);");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [&](const TString& word, const TString& line) {
+            Y_UNUSED(word);
+            UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("(Aggregate core '('\"group0\")"));
+        };
+
+        TWordCountHive elementStat({"Aggregate"});
+        VerifyProgram(res, elementStat, verifyLine);
+        UNIT_ASSERT(elementStat["Aggregate"] == 1);
+    }
+
+    Y_UNIT_TEST(AllowGroupByWithParens) {
+        NYql::TAstParseResult res = SqlToYql("select count(*) from plato.Input group by (x, y as alias1, z);");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [&](const TString& word, const TString& line) {
+            Y_UNUSED(word);
+            UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("(Aggregate core '('\"x\" '\"alias1\" '\"z\")"));
+        };
+
+        TWordCountHive elementStat({"Aggregate"});
+        VerifyProgram(res, elementStat, verifyLine);
+        UNIT_ASSERT(elementStat["Aggregate"] == 1);
+    }
+
+    Y_UNIT_TEST(CreateAsyncReplicationParseCorrect) {
+        auto req = R"(
+            USE plato;
+            CREATE ASYNC REPLICATION MyReplication
+            FOR table1 AS table2, table3 AS table4
+            WITH (
+                CONNECTION_STRING = "grpc://localhost:2135/?database=/MyDatabase",
+                ENDPOINT = "localhost:2135",
+                DATABASE = "/MyDatabase"
+            );
+        )";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("MyReplication"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("create"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("table1"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("table2"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("table3"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("table4"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("connection_string"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("grpc://localhost:2135/?database=/MyDatabase"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("endpoint"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("localhost:2135"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("database"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("/MyDatabase"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(CreateAsyncReplicationUnsupportedSettings) {
+        auto reqTpl = R"(
+            USE plato;
+            CREATE ASYNC REPLICATION MyReplication
+            FOR table1 AS table2, table3 AS table4
+            WITH (
+                %s = "%s"
+            )
+        )";
+
+        auto settings = THashMap<TString, TString>{
+            {"STATE", "DONE"},
+            {"FAILOVER_MODE", "FORCE"},
+        };
+
+        for (const auto& [k, v] : settings) {
+            auto req = Sprintf(reqTpl, k.c_str(), v.c_str());
+            auto res = SqlToYql(req);
+            UNIT_ASSERT(!res.Root);
+            UNIT_ASSERT_NO_DIFF(Err2Str(res), Sprintf("<main>:6:%zu: Error: %s is not supported in CREATE\n", 20 + k.size(), k.c_str()));
+        }
+    }
+
+    Y_UNIT_TEST(AlterAsyncReplicationParseCorrect) {
+        auto req = R"(
+            USE plato;
+            ALTER ASYNC REPLICATION MyReplication
+            SET (
+                STATE = "DONE",
+                FAILOVER_MODE = "FORCE"
+            );
+        )";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("MyReplication"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("alter"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("state"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("DONE"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("failover_mode"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("FORCE"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(AlterAsyncReplicationUnsupportedSettings) {
+        auto reqTpl = R"(
+            USE plato;
+            ALTER ASYNC REPLICATION MyReplication
+            SET (
+                %s = "%s"
+            )
+        )";
+
+        auto settings = THashMap<TString, TString>{
+            {"connection_string", "grpc://localhost:2135/?database=/MyDatabase"},
+            {"endpoint", "localhost:2135"},
+            {"database", "/MyDatabase"},
+            {"token", "foo"},
+            {"token_secret_name", "foo_secret_name"},
+            {"user", "user"},
+            {"password", "bar"},
+            {"password_secret_name", "bar_secret_name"},
+        };
+
+        for (const auto& setting : settings) {
+            auto& key = setting.first;
+            auto& value = setting.second;
+            auto req = Sprintf(reqTpl, key.c_str(), value.c_str());
+            auto res = SqlToYql(req);
+            UNIT_ASSERT(res.Root);
+            
+            TVerifyLineFunc verifyLine = [&key, &value](const TString& word, const TString& line) {
+                if (word == "Write") {
+                    UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("MyReplication"));
+                    UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("alter"));
+                    UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(key));
+                    UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(value));
+                }
+            };
+
+            TWordCountHive elementStat = { {TString("Write"), 0}};
+            VerifyProgram(res, elementStat, verifyLine);
+
+            UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+        }
+    }
+
+    Y_UNIT_TEST(AsyncReplicationInvalidSettings) {
+        auto req = R"(
+            USE plato;
+            ALTER ASYNC REPLICATION MyReplication SET (FOO = "BAR");
+        )";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:3:62: Error: Unknown replication setting: FOO\n");
+    }
+
+    Y_UNIT_TEST(DropAsyncReplicationParseCorrect) {
+        auto req = R"(
+            USE plato;
+            DROP ASYNC REPLICATION MyReplication;
+        )";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("MyReplication"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("drop"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(DropAsyncReplicationCascade) {
+        auto req = R"(
+            USE plato;
+            DROP ASYNC REPLICATION MyReplication CASCADE;
+        )";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("dropCascade"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(PragmaCompactGroupBy) {
+        auto req = "PRAGMA CompactGroupBy; SELECT key, COUNT(*) FROM plato.Input GROUP BY key;";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Aggregate") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("'('compact)"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Aggregate"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Aggregate"]);
+    }
+
+    Y_UNIT_TEST(PragmaDisableCompactGroupBy) {
+        auto req = "PRAGMA DisableCompactGroupBy; SELECT key, COUNT(*) FROM plato.Input GROUP /*+ compact() */ BY key;";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Aggregate") {
+                UNIT_ASSERT_VALUES_EQUAL(TString::npos, line.find("'('compact)"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Aggregate"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Aggregate"]);
+    }
+
+    Y_UNIT_TEST(AutoSampleWorksWithNamedSubquery) {
+        UNIT_ASSERT(SqlToYql("$src = select * from plato.Input; select * from $src sample 0.2").IsOk());
+    }
+
+    Y_UNIT_TEST(AutoSampleWorksWithSubquery) {
+        UNIT_ASSERT(SqlToYql("select * from (select * from plato.Input) sample 0.2").IsOk());
+    }
+
+    Y_UNIT_TEST(CreateTableTrailingComma) {
+        UNIT_ASSERT(SqlToYql("USE plato; CREATE TABLE tableName (Key Uint32, PRIMARY KEY (Key),);").IsOk());
+        UNIT_ASSERT(SqlToYql("USE plato; CREATE TABLE tableName (Key Uint32,);").IsOk());
+    }
+
+    Y_UNIT_TEST(BetweenSymmetric) {
+        UNIT_ASSERT(SqlToYql("select 3 between symmetric 5 and 4;").IsOk());
+        UNIT_ASSERT(SqlToYql("select 3 between asymmetric 5 and 4;").IsOk());
+        UNIT_ASSERT(SqlToYql("use plato; select key between symmetric and and and from Input;").IsOk());
+        UNIT_ASSERT(SqlToYql("use plato; select key between and and and from Input;").IsOk());
+    }
+}
+
+Y_UNIT_TEST_SUITE(ExternalFunction) {
+    Y_UNIT_TEST(ValidUseFunctions) {
+
+        UNIT_ASSERT(SqlToYql(
+                "PROCESS plato.Input"
+                " USING EXTERNAL FUNCTION('YANDEX-CLOUD', 'foo', <|a: 123, b: a + 641|>)"
+                " WITH INPUT_TYPE=Struct<a:Int32>, OUTPUT_TYPE=Struct<b:Int32>,"
+                " CONCURRENCY=3, OPTIMIZE_FOR='CALLS'").IsOk());
+
+        // use CALLS without quotes, as keyword
+        UNIT_ASSERT(SqlToYql(
+                "PROCESS plato.Input"
+                " USING EXTERNAL FUNCTION('YANDEX-CLOUD', 'foo')"
+                " WITH INPUT_TYPE=Struct<a:Int32>, OUTPUT_TYPE=Struct<b:Int32>,"
+                " OPTIMIZE_FOR=CALLS").IsOk());
+
+        UNIT_ASSERT(SqlToYql(
+                "PROCESS plato.Input"
+                " USING EXTERNAL FUNCTION('YANDEX-CLOUD', 'foo', TableRow())"
+                " WITH INPUT_TYPE=Struct<a:Int32>, OUTPUT_TYPE=Struct<b:Int32>,"
+                " CONCURRENCY=3").IsOk());
+
+        UNIT_ASSERT(SqlToYql(
+                "PROCESS plato.Input"
+                " USING EXTERNAL FUNCTION('YANDEX-CLOUD', 'foo')"
+                " WITH INPUT_TYPE=Struct<a:Int32>, OUTPUT_TYPE=Struct<b:Int32>,"
+                " CONCURRENCY=3, BATCH_SIZE=1000000, CONNECTION='yc-folder34fse-con',"
+                " INIT=[0, 900]").IsOk());
+
+        UNIT_ASSERT(SqlToYql(
+                "PROCESS plato.Input"
+                " USING EXTERNAL FUNCTION('YANDEX-CLOUD', 'bar', TableRow())"
+                " WITH UNKNOWN_PARAM_1='837747712', UNKNOWN_PARAM_2=Tuple<Uint16, Utf8>,"
+                " INPUT_TYPE=Struct<a:Int32>, OUTPUT_TYPE=Struct<b:Int32>").IsOk());
+    }
+
+
+    Y_UNIT_TEST(InValidUseFunctions) {
+        ExpectFailWithError("PROCESS plato.Input USING some::udf(*) WITH INPUT_TYPE=Struct<a:Int32>",
+                            "<main>:1:33: Error: PROCESS without USING EXTERNAL FUNCTION doesn't allow WITH block\n");
+
+        ExpectFailWithError("PROCESS plato.Input USING EXTERNAL FUNCTION('YANDEX-CLOUD', 'jhhjfh88134d')"
+                            " WITH INPUT_TYPE=Struct<a:Int32>, OUTPUT_TYPE=Struct<b:Int32>"
+                            " ASSUME ORDER BY key",
+                            "<main>:1:129: Error: PROCESS with USING EXTERNAL FUNCTION doesn't allow ASSUME block\n");
+
+        ExpectFailWithError("PROCESS plato.Input USING EXTERNAL FUNCTION('YANDEX-CLOUD', 'foo', 'bar', 'baz')",
+                            "<main>:1:15: Error: EXTERNAL FUNCTION requires from 2 to 3 arguments, but got: 4\n");
+
+        ExpectFailWithError("PROCESS plato.Input\n"
+                            " USING EXTERNAL FUNCTION('YANDEX-CLOUD', 'foo', <|field_1: a1, field_b: b1|>)\n"
+                            " WITH INPUT_TYPE=Struct<a:Int32>, OUTPUT_TYPE=Struct<b:Int32>,\n"
+                            " CONCURRENCY=3, BATCH_SIZE=1000000, CONNECTION='yc-folder34fse-con',\n"
+                            " CONCURRENCY=5, INPUT_TYPE=Struct<b:Bool>,\n"
+                            " INIT=[0, 900]\n",
+                            "<main>:5:2: Error: WITH \"CONCURRENCY\" clause should be specified only once\n"
+                            "<main>:5:17: Error: WITH \"INPUT_TYPE\" clause should be specified only once\n");
+    }
+}
+
+Y_UNIT_TEST_SUITE(SqlToYQLErrors) {
+    Y_UNIT_TEST(UdfSyntaxSugarMissingCall) {
+        auto req = "SELECT Udf(DateTime::FromString, \"foo\" as RunConfig);";
+        auto res = SqlToYql(req);
+        TString a1 = Err2Str(res);
+        TString a2("<main>:1:8: Error: Abstract Udf Node can't be used as a part of expression.\n");
+        UNIT_ASSERT_NO_DIFF(a1, a2);
+    }
+
+    Y_UNIT_TEST(UdfSyntaxSugarIsNotCallable) {
+        auto req = "SELECT Udf(123, \"foo\" as RunConfig);";
+        auto res = SqlToYql(req);
+        TString a1 = Err2Str(res);
+        TString a2("<main>:1:8: Error: Udf: first argument must be a callable, like Foo::Bar\n");
+        UNIT_ASSERT_NO_DIFF(a1, a2);
+    }
+
+    Y_UNIT_TEST(UdfSyntaxSugarNoArgs) {
+        auto req = "SELECT Udf()();";
+        auto res = SqlToYql(req);
+        TString a1 = Err2Str(res);
+        TString a2("<main>:1:8: Error: Udf: expected at least one argument\n");
+        UNIT_ASSERT_NO_DIFF(a1, a2);
+    }
+
+    Y_UNIT_TEST(StrayUTF8) {
+        /// 'c' in plato is russian here
+        NYql::TAstParseResult res = SqlToYql("select * from сedar.Input");
+        UNIT_ASSERT(!res.Root);
+
+        TString a1 = Err2Str(res);
+        TString a2(R"foo(<main>:1:16: Error: Unknown cluster: edar
+)foo");
+
+        UNIT_ASSERT_NO_DIFF(a1, a2);
+    }
+
+    Y_UNIT_TEST(IvalidStringLiteralWithEscapedBackslash) {
+        NYql::TAstParseResult res1 = SqlToYql(R"foo($bar = 'a\\'b';)foo");
+        NYql::TAstParseResult res2 = SqlToYql(R"foo($bar = "a\\"b";)foo");
+        UNIT_ASSERT(!res1.Root);
+        UNIT_ASSERT(!res2.Root);
+
+        UNIT_ASSERT_NO_DIFF(Err2Str(res1), "<main>:1:12: Error: mismatched input 'b' expecting {<EOF>, ';'}\n");
+        UNIT_ASSERT_NO_DIFF(Err2Str(res2), "<main>:1:12: Error: mismatched input 'b' expecting {<EOF>, ';'}\n");
+    }
+
+    Y_UNIT_TEST(InvalidHexInStringLiteral) {
+        NYql::TAstParseResult res = SqlToYql("select \"foo\\x1\\xfe\"");
+        UNIT_ASSERT(!res.Root);
+        TString a1 = Err2Str(res);
+        TString a2 = "<main>:1:15: Error: Failed to parse string literal: Invalid hexadecimal value\n";
+
+        UNIT_ASSERT_NO_DIFF(a1, a2);
+    }
+
+    Y_UNIT_TEST(InvalidOctalInMultilineStringLiteral) {
+        NYql::TAstParseResult res = SqlToYql("select \"foo\n"
+                                             "bar\n"
+                                             "\\01\"");
+        UNIT_ASSERT(!res.Root);
+        TString a1 = Err2Str(res);
+        TString a2 = "<main>:3:4: Error: Failed to parse string literal: Invalid octal value\n";
+
+        UNIT_ASSERT_NO_DIFF(a1, a2);
+    }
+
+    Y_UNIT_TEST(InvalidDoubleAtString) {
+        NYql::TAstParseResult res = SqlToYql("select @@@@@@");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:12: Error: extraneous input '@' expecting {<EOF>, ';'}\n");
+    }
+
+    Y_UNIT_TEST(InvalidDoubleAtStringWhichWasAcceptedEarlier) {
+        NYql::TAstParseResult res = SqlToYql("SELECT @@foo@@ @ @@bar@@");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:15: Error: mismatched input '@' expecting {<EOF>, ';'}\n");
+    }
+
+    Y_UNIT_TEST(InvalidStringFromTable) {
+        NYql::TAstParseResult res = SqlToYql("select \"FOO\"\"BAR from plato.foo");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:12: Error: mismatched input '\"' expecting {<EOF>, ';'}\n");
+    }
+
+    Y_UNIT_TEST(InvalidDoubleAtStringFromTable) {
+        NYql::TAstParseResult res = SqlToYql("select @@@@@@ from plato.foo");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:12: Error: mismatched input '@' expecting {<EOF>, ';'}\n");
+    }
+
+    Y_UNIT_TEST(SelectInvalidSyntax) {
+        NYql::TAstParseResult res = SqlToYql("select 1 form Wat");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:14: Error: extraneous input 'Wat' expecting {<EOF>, ';'}\n");
+    }
+
+    Y_UNIT_TEST(SelectNoCluster) {
+        NYql::TAstParseResult res = SqlToYql("select foo from bar");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:1: Error: No cluster name given and no default cluster is selected\n");
+    }
+
+    Y_UNIT_TEST(SelectDuplicateColumns) {
+        NYql::TAstParseResult res = SqlToYql("select a, a from plato.Input");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:11: Error: Unable to use duplicate column names. Collision in name: a\n");
+    }
+
+    Y_UNIT_TEST(SelectDuplicateLabels) {
+        NYql::TAstParseResult res = SqlToYql("select a as foo, b as foo from plato.Input");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:18: Error: Unable to use duplicate column names. Collision in name: foo\n");
+    }
+
+    Y_UNIT_TEST(SelectCaseWithoutThen) {
+        NYql::TAstParseResult res = SqlToYql("select case when true 1;");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res),
+            "<main>:1:22: Error: missing THEN at \'1\'\n"
+            "<main>:1:23: Error: extraneous input \';\' expecting {ELSE, END, WHEN}\n"
+        );
+    }
+
+    Y_UNIT_TEST(SelectComplexCaseWithoutThen) {
+        NYql::TAstParseResult res = SqlToYql(
+            "SELECT *\n"
+            "FROM plato.Input AS a\n"
+            "WHERE CASE WHEN a.key = \"foo\" a.subkey ELSE a.value END\n"
+        );
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:3:30: Error: missing THEN at 'a'\n");
+    }
+
+    Y_UNIT_TEST(SelectCaseWithoutEnd) {
+        NYql::TAstParseResult res = SqlToYql("select case a when b then c end from plato.Input");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:8: Error: ELSE is required\n");
+    }
+
+    Y_UNIT_TEST(SelectWithBadAggregationNoInput) {
+        NYql::TAstParseResult res = SqlToYql("select a, Min(b), c");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res),
+           "<main>:1:1: Error: Column references are not allowed without FROM\n"
+           "<main>:1:8: Error: Column reference 'a'\n"
+           "<main>:1:1: Error: Column references are not allowed without FROM\n"
+           "<main>:1:15: Error: Column reference 'b'\n"
+           "<main>:1:1: Error: Column references are not allowed without FROM\n"
+           "<main>:1:19: Error: Column reference 'c'\n"
+        );
+    }
+
+    Y_UNIT_TEST(SelectWithBadAggregation) {
+        ExpectFailWithError("select count(*), 1 + key from plato.Input",
+            "<main>:1:22: Error: Column `key` must either be a key column in GROUP BY or it should be used in aggregation function\n");
+    }
+
+    Y_UNIT_TEST(SelectWithBadAggregatedTerms) {
+        ExpectFailWithError("select key, 2 * subkey from plato.Input group by key",
+            "<main>:1:17: Error: Column `subkey` must either be a key column in GROUP BY or it should be used in aggregation function\n");
+    }
+
+    Y_UNIT_TEST(SelectDistinctWithBadAggregation) {
+        ExpectFailWithError("select distinct count(*), 1 + key from plato.Input",
+            "<main>:1:31: Error: Column `key` must either be a key column in GROUP BY or it should be used in aggregation function\n");
+        ExpectFailWithError("select distinct key, 2 * subkey from plato.Input group by key",
+            "<main>:1:26: Error: Column `subkey` must either be a key column in GROUP BY or it should be used in aggregation function\n");
+    }
+
+    Y_UNIT_TEST(SelectWithBadAggregationInHaving) {
+        ExpectFailWithError("select key from plato.Input group by key\n"
+                            "having \"f\" || value == \"foo\"",
+            "<main>:2:15: Error: Column `value` must either be a key column in GROUP BY or it should be used in aggregation function\n");
+    }
+
+    Y_UNIT_TEST(JoinWithNonAggregatedColumnInProjection) {
+        ExpectFailWithError("select a.key, 1 + b.subkey\n"
+                            "from plato.Input1 as a join plato.Input2 as b using(key)\n"
+                            "group by a.key;",
+            "<main>:1:19: Error: Column `b.subkey` must either be a key column in GROUP BY or it should be used in aggregation function\n");
+
+        ExpectFailWithError("select a.key, 1 + b.subkey.x\n"
+                            "from plato.Input1 as a join plato.Input2 as b using(key)\n"
+                            "group by a.key;",
+            "<main>:1:19: Error: Column must either be a key column in GROUP BY or it should be used in aggregation function\n");
+    }
+
+    Y_UNIT_TEST(SelectWithBadAggregatedTermsWithSources) {
+        ExpectFailWithError("select key, 1 + a.subkey\n"
+                            "from plato.Input1 as a\n"
+                            "group by a.key;",
+            "<main>:1:17: Error: Column `a.subkey` must either be a key column in GROUP BY or it should be used in aggregation function\n");
+        ExpectFailWithError("select key, 1 + a.subkey.x\n"
+                            "from plato.Input1 as a\n"
+                            "group by a.key;",
+            "<main>:1:17: Error: Column must either be a key column in GROUP BY or it should be used in aggregation function\n");
+    }
+
+    Y_UNIT_TEST(WarnForAggregationBySelectAlias) {
+        NYql::TAstParseResult res = SqlToYql("select c + 1 as c from plato.Input\n"
+                                             "group by  c");
+        UNIT_ASSERT(res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res),
+            "<main>:2:11: Warning: GROUP BY will aggregate by column `c` instead of aggregating by SELECT expression with same alias, code: 4532\n"
+            "<main>:1:10: Warning: You should probably use alias in GROUP BY instead of using it here. Please consult documentation for more details, code: 4532\n");
+
+        res = SqlToYql("select c + 1 as c from plato.Input\n"
+                       "group by Math::Floor(c + 2) as c;");
+
+        UNIT_ASSERT(res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res),
+            "<main>:2:22: Warning: GROUP BY will aggregate by column `c` instead of aggregating by SELECT expression with same alias, code: 4532\n"
+            "<main>:1:10: Warning: You should probably use alias in GROUP BY instead of using it here. Please consult documentation for more details, code: 4532\n");
+    }
+
+    Y_UNIT_TEST(NoWarnForAggregationBySelectAliasWhenAggrFunctionsAreUsedInAlias) {
+        NYql::TAstParseResult res = SqlToYql("select\n"
+                                             "    cast(avg(val) as int) as value,\n"
+                                             "    value as key\n"
+                                             "from\n"
+                                             "    plato.Input\n"
+                                             "group by value");
+
+        UNIT_ASSERT(res.Root);
+        UNIT_ASSERT(res.Issues.Size() == 0);
+
+        res = SqlToYql("select\n"
+                       "    cast(avg(val) over w as int) as value,\n"
+                       "    value as key\n"
+                       "from\n"
+                       "    plato.Input\n"
+                       "group by value\n"
+                       "window w as ()");
+
+        UNIT_ASSERT(res.Root);
+        UNIT_ASSERT(res.Issues.Size() == 0);
+    }
+
+    Y_UNIT_TEST(NoWarnForAggregationBySelectAliasWhenQualifiedNameIsUsed) {
+        NYql::TAstParseResult res = SqlToYql("select\n"
+                                             "  Unwrap(a.key) as key\n"
+                                             "from plato.Input as a\n"
+                                             "join plato.Input2 as b using(k)\n"
+                                             "group by a.key;");
+        UNIT_ASSERT(res.Root);
+        UNIT_ASSERT(res.Issues.Size() == 0);
+
+        res = SqlToYql("select Unwrap(a.key) as key\n"
+                       "from plato.Input as a\n"
+                       "group by a.key;");
+        UNIT_ASSERT(res.Root);
+        UNIT_ASSERT(res.Issues.Size() == 0);
+    }
+
+    Y_UNIT_TEST(NoWarnForAggregationBySelectAliasWhenTrivialRenamingIsUsed) {
+        NYql::TAstParseResult res = SqlToYql("select a.key as key\n"
+                                             "from plato.Input as a\n"
+                                             "group by key;");
+        UNIT_ASSERT(res.Root);
+        UNIT_ASSERT(res.Issues.Size() == 0);
+
+        res = SqlToYql("select key as key\n"
+                       "from plato.Input\n"
+                       "group by key;");
+        UNIT_ASSERT(res.Root);
+        UNIT_ASSERT(res.Issues.Size() == 0);
+    }
+
+    Y_UNIT_TEST(ErrorByAggregatingByExpressionWithSameExpressionInSelect) {
+        ExpectFailWithError("select k * 2 from plato.Input group by k * 2",
+            "<main>:1:8: Error: Column `k` must either be a key column in GROUP BY or it should be used in aggregation function\n");
+    }
+
+    Y_UNIT_TEST(ErrorForAggregationBySelectAlias) {
+        ExpectFailWithError("select key, Math::Floor(1.1 + a.subkey) as foo\n"
+                            "from plato.Input as a\n"
+                            "group by a.key, foo;",
+            "<main>:3:17: Warning: GROUP BY will aggregate by column `foo` instead of aggregating by SELECT expression with same alias, code: 4532\n"
+            "<main>:1:19: Warning: You should probably use alias in GROUP BY instead of using it here. Please consult documentation for more details, code: 4532\n"
+            "<main>:1:31: Error: Column `a.subkey` must either be a key column in GROUP BY or it should be used in aggregation function\n");
+
+        ExpectFailWithError("select c + 1 as c from plato.Input\n"
+                            "group by Math::Floor(c + 2);",
+            "<main>:2:22: Warning: GROUP BY will aggregate by column `c` instead of aggregating by SELECT expression with same alias, code: 4532\n"
+            "<main>:1:10: Warning: You should probably use alias in GROUP BY instead of using it here. Please consult documentation for more details, code: 4532\n"
+            "<main>:1:8: Error: Column `c` must either be a key column in GROUP BY or it should be used in aggregation function\n");
+    }
+
+    Y_UNIT_TEST(SelectWithDuplicateGroupingColumns) {
+        NYql::TAstParseResult res = SqlToYql("select c from plato.Input group by c, c");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:8: Error: Duplicate grouping column: c\n");
+    }
+
+    Y_UNIT_TEST(SelectWithBadAggregationInGrouping) {
+        NYql::TAstParseResult res = SqlToYql("select a, Min(b), c group by c");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:1: Error: Column references are not allowed without FROM\n"
+            "<main>:1:30: Error: Column reference 'c'\n");
+    }
+
+    Y_UNIT_TEST(SelectWithOpOnBadAggregation) {
+        ExpectFailWithError("select 1 + a + Min(b) from plato.Input",
+            "<main>:1:12: Error: Column `a` must either be a key column in GROUP BY or it should be used in aggregation function\n");
+    }
+
+    Y_UNIT_TEST(SelectOrderByConstantNum) {
+        NYql::TAstParseResult res = SqlToYql("select a from plato.Input order by 1");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:36: Error: Unable to ORDER BY constant expression\n");
+    }
+
+    Y_UNIT_TEST(SelectOrderByConstantExpr) {
+        NYql::TAstParseResult res = SqlToYql("select a from plato.Input order by 1 * 42");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:38: Error: Unable to ORDER BY constant expression\n");
+    }
+
+    Y_UNIT_TEST(SelectOrderByConstantString) {
+        NYql::TAstParseResult res = SqlToYql("select a from plato.Input order by \"nest\"");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:36: Error: Unable to ORDER BY constant expression\n");
+    }
+
+    Y_UNIT_TEST(SelectOrderByAggregated) {
+        NYql::TAstParseResult res = SqlToYql("select a from plato.Input order by min(a)");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:36: Error: Unable to ORDER BY aggregated values\n");
+    }
+
+    Y_UNIT_TEST(ErrorInOrderByExpresison) {
+        NYql::TAstParseResult res = SqlToYql("select key, value from plato.Input order by (key as zey)");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:45: Error: You should use in ORDER BY column name, qualified field, callable function or expression\n");
+    }
+
+    Y_UNIT_TEST(ErrorsInOrderByWhenColumnIsMissingInProjection) {
+        ExpectFailWithError("select subkey from (select 1 as subkey) order by key", "<main>:1:50: Error: Column key is not in source column set\n");
+        ExpectFailWithError("select subkey from plato.Input as a order by x.key", "<main>:1:46: Error: Unknown correlation name: x\n");
+        ExpectFailWithError("select distinct a, b from plato.Input order by c", "<main>:1:48: Error: Column c is not in source column set. Did you mean a?\n");
+        ExpectFailWithError("select count(*) as a from plato.Input order by c", "<main>:1:48: Error: Column c is not in source column set. Did you mean a?\n");
+        ExpectFailWithError("select count(*) as a, b, from plato.Input group by b order by c", "<main>:1:63: Error: Column c is not in source column set. Did you mean a?\n");
+        UNIT_ASSERT(SqlToYql("select a, b from plato.Input order by c").IsOk());
+    }
+
+    Y_UNIT_TEST(SelectAggregatedWhere) {
+        NYql::TAstParseResult res = SqlToYql("select * from plato.Input where count(key)");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:33: Error: Can not use aggregated values in filtering\n");
+    }
+
+    Y_UNIT_TEST(DoubleFrom) {
+        NYql::TAstParseResult res = SqlToYql("from plato.Input select * from plato.Input");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:27: Error: Only one FROM clause is allowed\n");
+    }
+
+    Y_UNIT_TEST(SelectJoinMissingCorrName) {
+        NYql::TAstParseResult res = SqlToYql("select * from plato.Input1 as a join plato.Input2 as b on a.key == key");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:65: Error: JOIN: column requires correlation name\n");
+    }
+
+    Y_UNIT_TEST(SelectJoinMissingCorrName1) {
+        NYql::TAstParseResult res = SqlToYql(
+            "use plato;\n"
+            "$foo = select * from Input1;\n"
+            "select * from Input2 join $foo USING(key);\n"
+        );
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:3:27: Error: JOIN: missing correlation name for source\n");
+    }
+
+    Y_UNIT_TEST(SelectJoinMissingCorrName2) {
+        NYql::TAstParseResult res = SqlToYql(
+            "use plato;\n"
+            "$foo = select * from Input1;\n"
+            "select * from Input2 cross join $foo;\n"
+        );
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:3:33: Error: JOIN: missing correlation name for source\n");
+    }
+
+    Y_UNIT_TEST(SelectJoinEmptyCorrNames) {
+        NYql::TAstParseResult res = SqlToYql(
+            "$left = (SELECT * FROM plato.Input1 LIMIT 2);\n"
+            "$right = (SELECT * FROM plato.Input2 LIMIT 2);\n"
+            "SELECT * FROM $left FULL JOIN $right USING (key);\n"
+        );
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:3:45: Error: At least one correlation name is required in join\n");
+    }
+
+    Y_UNIT_TEST(SelectJoinSameCorrNames) {
+        NYql::TAstParseResult res = SqlToYql("SELECT Input.key FROM plato.Input JOIN plato.Input1 ON Input.key == Input.subkey\n");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:66: Error: JOIN: different correlation names are required for joined tables\n");
+    }
+
+    Y_UNIT_TEST(SelectJoinConstPredicateArg) {
+        NYql::TAstParseResult res = SqlToYql("SELECT * FROM plato.Input1 as A JOIN plato.Input2 as B ON A.key == B.key AND A.subkey == \"wtf\"\n");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:87: Error: JOIN: each equality predicate argument must depend on exactly one JOIN input\n");
+    }
+
+    Y_UNIT_TEST(SelectJoinNonEqualityPredicate) {
+        NYql::TAstParseResult res = SqlToYql("SELECT * FROM plato.Input1 as A JOIN plato.Input2 as B ON A.key == B.key AND A.subkey > B.subkey\n");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:87: Error: JOIN ON expression must be a conjunction of equality predicates\n");
+    }
+
+    Y_UNIT_TEST(SelectEquiJoinCorrNameOutOfScope) {
+        NYql::TAstParseResult res = SqlToYql(
+            "PRAGMA equijoin;\n"
+            "SELECT * FROM plato.A JOIN plato.B ON A.key == C.key JOIN plato.C ON A.subkey == C.subkey;\n"
+        );
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:2:45: Error: JOIN: can not use source: C in equality predicate, it is out of current join scope\n");
+    }
+
+    Y_UNIT_TEST(SelectEquiJoinNoRightSource) {
+        NYql::TAstParseResult res = SqlToYql(
+            "PRAGMA equijoin;\n"
+            "SELECT * FROM plato.A JOIN plato.B ON A.key == B.key JOIN plato.C ON A.subkey == B.subkey;\n"
+        );
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:2:79: Error: JOIN ON equality predicate must have one of its arguments from the rightmost source\n");
+    }
+
+    Y_UNIT_TEST(SelectEquiJoinOuterWithoutType) {
+        NYql::TAstParseResult res = SqlToYql(
+            "SELECT * FROM plato.A Outer JOIN plato.B ON A.key == B.key;\n"
+        );
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:23: Error: Invalid join type: OUTER JOIN. OUTER keyword is optional and can only be used after LEFT, RIGHT or FULL\n");
+    }
+
+    Y_UNIT_TEST(SelectEquiJoinOuterWithWrongType) {
+        NYql::TAstParseResult res = SqlToYql(
+            "SELECT * FROM plato.A LEFT semi OUTER JOIN plato.B ON A.key == B.key;\n"
+            );
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:33: Error: Invalid join type: LEFT SEMI OUTER JOIN. OUTER keyword is optional and can only be used after LEFT, RIGHT or FULL\n");
+    }
+
+    Y_UNIT_TEST(InsertNoCluster) {
+        NYql::TAstParseResult res = SqlToYql("insert into Output (foo) values (1)");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:1: Error: No cluster name given and no default cluster is selected\n");
+    }
+
+    Y_UNIT_TEST(InsertValuesNoLabels) {
+        NYql::TAstParseResult res = SqlToYql("insert into plato.Output values (1)");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:19: Error: INSERT INTO ... VALUES requires specification of table columns\n");
+    }
+
+    Y_UNIT_TEST(UpsertValuesNoLabelsKikimr) {
+        NYql::TAstParseResult res = SqlToYql("upsert into plato.Output values (1)", 10, TString(NYql::KikimrProviderName));
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:19: Error: UPSERT INTO ... VALUES requires specification of table columns\n");
+    }
+
+    Y_UNIT_TEST(ReplaceValuesNoLabelsKikimr) {
+        NYql::TAstParseResult res = SqlToYql("replace into plato.Output values (1)", 10, TString(NYql::KikimrProviderName));
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:20: Error: REPLACE INTO ... VALUES requires specification of table columns\n");
+    }
+
+    Y_UNIT_TEST(InsertValuesInvalidLabels) {
+        NYql::TAstParseResult res = SqlToYql("insert into plato.Output (foo) values (1, 2)");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:27: Error: VALUES have 2 columns, INSERT INTO expects: 1\n");
+    }
+
+    Y_UNIT_TEST(BuiltinFileOpNoArgs) {
+        NYql::TAstParseResult res = SqlToYql("select FilePath()");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:8: Error: FilePath() requires exactly 1 arguments, given: 0\n");
+    }
+
+    Y_UNIT_TEST(ProcessWithHaving) {
+        NYql::TAstParseResult res = SqlToYql("process plato.Input using some::udf(value) having value == 1");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:15: Error: PROCESS does not allow HAVING yet! You may request it on yql@ maillist.\n");
+    }
+
+    Y_UNIT_TEST(ReduceNoBy) {
+        NYql::TAstParseResult res = SqlToYql("reduce plato.Input using some::udf(value)");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:19: Error: mismatched input 'using' expecting {',', ON, PRESORT}\n");
+    }
+
+    Y_UNIT_TEST(ReduceDistinct) {
+        NYql::TAstParseResult res = SqlToYql("reduce plato.Input on key using some::udf(distinct value)");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:43: Error: DISTINCT can not be used in PROCESS/REDUCE\n");
+    }
+
+    Y_UNIT_TEST(CreateTableWithView) {
+        NYql::TAstParseResult res = SqlToYql("CREATE TABLE plato.foo:bar (key INT);");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:22: Error: mismatched input ':' expecting '('\n");
+    }
+
+    Y_UNIT_TEST(AsteriskWithSomethingAfter) {
+        NYql::TAstParseResult res = SqlToYql("select *, LENGTH(value) from plato.Input;");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:8: Error: Unable to use plain '*' with other projection items. Please use qualified asterisk instead: '<table>.*' (<table> can be either table name or table alias).\n");
+    }
+
+    Y_UNIT_TEST(AsteriskWithSomethingBefore) {
+        NYql::TAstParseResult res = SqlToYql("select LENGTH(value), * from plato.Input;");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:23: Error: Unable to use plain '*' with other projection items. Please use qualified asterisk instead: '<table>.*' (<table> can be either table name or table alias).\n");
+    }
+
+    Y_UNIT_TEST(DuplicatedQualifiedAsterisk) {
+        NYql::TAstParseResult res = SqlToYql("select in.*, key, in.* from plato.Input as in;");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:19: Error: Unable to use twice same quialified asterisk. Invalid source: in\n");
+    }
+
+    Y_UNIT_TEST(BrokenLabel) {
+        NYql::TAstParseResult res = SqlToYql("select in.*, key as `funny.label` from plato.Input as in;");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:14: Error: Unable to use '.' in column name. Invalid column name: funny.label\n");
+    }
+
+    Y_UNIT_TEST(KeyConflictDetect0) {
+        NYql::TAstParseResult res = SqlToYql("select key, in.key as key from plato.Input as in;");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:13: Error: Unable to use duplicate column names. Collision in name: key\n");
+    }
+
+    Y_UNIT_TEST(KeyConflictDetect1) {
+        NYql::TAstParseResult res = SqlToYql("select length(key) as key, key from plato.Input;");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:28: Error: Unable to use duplicate column names. Collision in name: key\n");
+    }
+
+    Y_UNIT_TEST(KeyConflictDetect2) {
+        NYql::TAstParseResult res = SqlToYql("select key, in.key from plato.Input as in;");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:1: Error: Duplicate column: key\n");
+    }
+
+    Y_UNIT_TEST(AutogenerationAliasWithCollisionConflict1) {
+        UNIT_ASSERT(SqlToYql("select LENGTH(Value), key as column0 from plato.Input;").IsOk());
+    }
+
+    Y_UNIT_TEST(AutogenerationAliasWithCollisionConflict2) {
+        UNIT_ASSERT(SqlToYql("select key as column1, LENGTH(Value) from plato.Input;").IsOk());
+    }
+
+    Y_UNIT_TEST(MissedSourceTableForQualifiedAsteriskOnSimpleSelect) {
+        NYql::TAstParseResult res = SqlToYql("use plato; select Intop.*, Input.key from plato.Input;");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:19: Error: Unknown correlation name: Intop\n");
+    }
+
+    Y_UNIT_TEST(MissedSourceTableForQualifiedAsteriskOnJoin) {
+        NYql::TAstParseResult res = SqlToYql("use plato; select tmissed.*, t2.*, t1.key from plato.Input as t1 join plato.Input as t2 on t1.key==t2.key;");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:19: Error: Unknown correlation name for asterisk: tmissed\n");
+    }
+
+    Y_UNIT_TEST(UnableToReferenceOnNotExistSubcolumn) {
+        NYql::TAstParseResult res = SqlToYql("select b.subkey from (select key from plato.Input as a) as b;");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:8: Error: Column subkey is not in source column set\n");
+    }
+
+    Y_UNIT_TEST(ConflictOnSameNameWithQualify0) {
+        NYql::TAstParseResult res = SqlToYql("select in.key, in.key as key from plato.Input as in;");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:1: Error: Duplicate column: key\n");
+    }
+
+    Y_UNIT_TEST(ConflictOnSameNameWithQualify1) {
+        NYql::TAstParseResult res = SqlToYql("select in.key, length(key) as key from plato.Input as in;");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:1: Error: Duplicate column: key\n");
+    }
+
+    Y_UNIT_TEST(ConflictOnSameNameWithQualify2) {
+        NYql::TAstParseResult res = SqlToYql("select key, in.key from plato.Input as in;");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:1: Error: Duplicate column: key\n");
+    }
+
+    Y_UNIT_TEST(ConflictOnSameNameWithQualify3) {
+        NYql::TAstParseResult res = SqlToYql("select in.key, subkey as key from plato.Input as in;");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:1: Error: Duplicate column: key\n");
+    }
+
+    Y_UNIT_TEST(SelectFlattenBySameColumns) {
+        NYql::TAstParseResult res = SqlToYql("select key from plato.Input flatten by (key, key as kk)");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:46: Error: Duplicate column name found: key in FlattenBy section\n");
+    }
+
+    Y_UNIT_TEST(SelectFlattenBySameAliases) {
+        NYql::TAstParseResult res = SqlToYql("select key from plato.Input flatten by (key as kk, subkey as kk);");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:52: Error: Duplicate alias found: kk in FlattenBy section\n");
+    }
+
+    Y_UNIT_TEST(SelectFlattenByExprSameAliases) {
+        NYql::TAstParseResult res = SqlToYql("select key from plato.Input flatten by (key as kk, ListSkip(subkey,1) as kk);");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:52: Error: Collision between alias and column name: kk in FlattenBy section\n");
+    }
+
+    Y_UNIT_TEST(SelectFlattenByConflictNameAndAlias0) {
+        NYql::TAstParseResult res = SqlToYql("select key from plato.Input flatten by (key, subkey as key);");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:46: Error: Collision between alias and column name: key in FlattenBy section\n");
+    }
+
+    Y_UNIT_TEST(SelectFlattenByConflictNameAndAlias1) {
+        NYql::TAstParseResult res = SqlToYql("select key from plato.Input flatten by (key as kk, subkey as key);");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:52: Error: Collision between alias and column name: key in FlattenBy section\n");
+    }
+
+    Y_UNIT_TEST(SelectFlattenByExprConflictNameAndAlias1) {
+        NYql::TAstParseResult res = SqlToYql("select key from plato.Input flatten by (key as kk, ListSkip(subkey,1) as key);");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:52: Error: Duplicate column name found: key in FlattenBy section\n");
+    }
+
+    Y_UNIT_TEST(SelectFlattenByUnnamedExpr) {
+        NYql::TAstParseResult res = SqlToYql("select key from plato.Input flatten by (key, ListSkip(key, 1))");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:46: Error: Unnamed expression after FLATTEN BY is not allowed\n");
+    }
+
+    Y_UNIT_TEST(UseInOnStrings) {
+        NYql::TAstParseResult res = SqlToYql("select * from plato.Input where \"foo\" in \"foovalue\";");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:42: Error: Unable to use IN predicate with string argument, it won't search substring - "
+                                          "expecting tuple, list, dict or single column table source\n");
+    }
+
+    Y_UNIT_TEST(UseSubqueryInScalarContextInsideIn) {
+        NYql::TAstParseResult res = SqlToYql("$q = (select key from plato.Input); select * from plato.Input where subkey in ($q);");
+        UNIT_ASSERT(res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:79: Warning: Using subrequest in scalar context after IN, "
+                                          "perhaps you should remove parenthesis here, code: 4501\n");
+    }
+
+    Y_UNIT_TEST(InHintsWithKeywordClash) {
+        NYql::TAstParseResult res = SqlToYql("SELECT COMPACT FROM plato.Input WHERE COMPACT IN COMPACT `COMPACT`(1,2,3)");
+        UNIT_ASSERT(!res.Root);
+        // should try to parse last compact as call expression
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:58: Error: Unknown builtin: COMPACT\n");
+    }
+
+    Y_UNIT_TEST(ErrorColumnPosition) {
+        NYql::TAstParseResult res = SqlToYql(
+            "USE plato;\n"
+            "SELECT \n"
+            "value FROM (\n"
+            "select key from Input\n"
+            ");\n"
+        );
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:3:1: Error: Column value is not in source column set\n");
+    }
+
+    Y_UNIT_TEST(PrimaryViewAbortMapReduce) {
+        NYql::TAstParseResult res = SqlToYql("SELECT key FROM plato.Input VIEW PRIMARY KEY");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:17: Error: primary view is not supported for yt tables\n");
+    }
+
+    Y_UNIT_TEST(InsertAbortMapReduce) {
+        NYql::TAstParseResult res = SqlToYql("INSERT OR ABORT INTO plato.Output SELECT key FROM plato.Input");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:0: Error: INSERT OR ABORT INTO is not supported for yt tables\n");
+    }
+
+    Y_UNIT_TEST(ReplaceIntoMapReduce) {
+        NYql::TAstParseResult res = SqlToYql("REPLACE INTO plato.Output SELECT key FROM plato.Input");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:0: Error: Meaning of REPLACE INTO has been changed, now you should use INSERT INTO <table> WITH TRUNCATE ... for yt\n");
+    }
+
+    Y_UNIT_TEST(UpsertIntoMapReduce) {
+        NYql::TAstParseResult res = SqlToYql("UPSERT INTO plato.Output SELECT key FROM plato.Input");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:0: Error: UPSERT INTO is not supported for yt tables\n");
+    }
+
+    Y_UNIT_TEST(UpdateMapReduce) {
+        NYql::TAstParseResult res = SqlToYql("UPDATE plato.Output SET value = value + 1 WHERE key < 1");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:0: Error: UPDATE is unsupported for yt\n");
+    }
+
+    Y_UNIT_TEST(DeleteMapReduce) {
+        NYql::TAstParseResult res = SqlToYql("DELETE FROM plato.Output WHERE key < 1");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:0: Error: DELETE is unsupported for yt\n");
+    }
+
+    Y_UNIT_TEST(ReplaceIntoWithTruncate) {
+        NYql::TAstParseResult res = SqlToYql("REPLACE INTO plato.Output WITH TRUNCATE SELECT key FROM plato.Input");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:32: Error: Unable REPLACE INTO with truncate mode\n");
+    }
+
+    Y_UNIT_TEST(UpsertIntoWithTruncate) {
+        NYql::TAstParseResult res = SqlToYql("UPSERT INTO plato.Output WITH TRUNCATE SELECT key FROM plato.Input");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:31: Error: Unable UPSERT INTO with truncate mode\n");
+    }
+
+    Y_UNIT_TEST(InsertIntoWithTruncateKikimr) {
+        NYql::TAstParseResult res = SqlToYql("INSERT INTO plato.Output WITH TRUNCATE SELECT key FROM plato.Input", 10, TString(NYql::KikimrProviderName));
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:0: Error: INSERT INTO WITH TRUNCATE is not supported for kikimr tables\n");
+    }
+
+    Y_UNIT_TEST(InsertIntoWithWrongArgumentCount) {
+        NYql::TAstParseResult res = SqlToYql("insert into plato.Output with truncate (key, value, subkey) values (5, '1', '2', '3');");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:53: Error: VALUES have 4 columns, INSERT INTO ... WITH TRUNCATE expects: 3\n");
+    }
+
+    Y_UNIT_TEST(UpsertWithWrongArgumentCount) {
+        NYql::TAstParseResult res = SqlToYql("upsert into plato.Output (key, value, subkey) values (2, '3');", 10, TString(NYql::KikimrProviderName));
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:39: Error: VALUES have 2 columns, UPSERT INTO expects: 3\n");
+    }
+
+    Y_UNIT_TEST(GroupingSetByExprWithoutAlias) {
+        NYql::TAstParseResult res = SqlToYql("SELECT key FROM plato.Input GROUP BY GROUPING SETS (cast(key as uint32), subkey);");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:53: Error: Unnamed expressions are not supported in GROUPING SETS. Please use '<expr> AS <name>'.\n");
+    }
+
+    Y_UNIT_TEST(GroupingSetByExprWithoutAlias2) {
+        NYql::TAstParseResult res = SqlToYql("SELECT key FROM plato.Input GROUP BY subkey || subkey, GROUPING SETS (\n"
+                                             "cast(key as uint32), subkey);");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:2:1: Error: Unnamed expressions are not supported in GROUPING SETS. Please use '<expr> AS <name>'.\n");
+    }
+
+    Y_UNIT_TEST(CubeByExprWithoutAlias) {
+        NYql::TAstParseResult res = SqlToYql("SELECT key FROM plato.Input GROUP BY CUBE (key, subkey / key);");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:56: Error: Unnamed expressions are not supported in CUBE. Please use '<expr> AS <name>'.\n");
+    }
+
+    Y_UNIT_TEST(RollupByExprWithoutAlias) {
+        NYql::TAstParseResult res = SqlToYql("SELECT key FROM plato.Input GROUP BY ROLLUP (subkey / key);");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:53: Error: Unnamed expressions are not supported in ROLLUP. Please use '<expr> AS <name>'.\n");
+    }
+
+    Y_UNIT_TEST(GroupByHugeCubeDeniedNoPragma) {
+        NYql::TAstParseResult res = SqlToYql("SELECT key FROM plato.Input GROUP BY CUBE (key, subkey, value, key + subkey as sum, key - subkey as sub, key + val as keyval);");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:119: Error: GROUP BY CUBE is allowed only for 5 columns, but you use 6\n");
+    }
+
+    Y_UNIT_TEST(GroupByInvalidPragma) {
+        NYql::TAstParseResult res = SqlToYql("PRAGMA GroupByCubeLimit = '-4';");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:27: Error: Expected unsigned integer literal as a single argument for: GroupByCubeLimit\n");
+    }
+
+    Y_UNIT_TEST(GroupByHugeCubeDeniedPragme) {
+        NYql::TAstParseResult res = SqlToYql("PRAGMA GroupByCubeLimit = '4'; SELECT key FROM plato.Input GROUP BY CUBE (key, subkey, value, key + subkey as sum, key - subkey as sub);");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:132: Error: GROUP BY CUBE is allowed only for 4 columns, but you use 5\n");
+    }
+
+    Y_UNIT_TEST(GroupByFewBigCubes) {
+        NYql::TAstParseResult res = SqlToYql("SELECT key FROM plato.Input GROUP BY CUBE(key, subkey, key + subkey as sum), CUBE(value, value + key + subkey as total);");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:1: Error: Unable to GROUP BY more than 64 groups, you try use 80 groups\n");
+    }
+
+    Y_UNIT_TEST(GroupByFewBigCubesWithPragmaLimit) {
+        NYql::TAstParseResult res = SqlToYql("PRAGMA GroupByLimit = '16'; SELECT key FROM plato.Input GROUP BY GROUPING SETS(key, subkey, key + subkey as sum), ROLLUP(value, value + key + subkey as total);");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:29: Error: Unable to GROUP BY more than 16 groups, you try use 18 groups\n");
+    }
+
+    Y_UNIT_TEST(NoGroupingColumn0) {
+        NYql::TAstParseResult res = SqlToYql(
+            "select count(1), key_first, val_first, grouping(key_first, val_first, nomind) as group\n"
+            "from plato.Input group by grouping sets (cast(key as uint32) /100 as key_first, Substring(value, 1, 1) as val_first);");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:71: Error: Column 'nomind' is not a grouping column\n");
+    }
+
+    Y_UNIT_TEST(NoGroupingColumn1) {
+        NYql::TAstParseResult res = SqlToYql("select count(1), grouping(key, value) as group_duo from plato.Input group by cube (key, subkey);");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:32: Error: Column 'value' is not a grouping column\n");
+    }
+
+    Y_UNIT_TEST(EmptyAccess0) {
+        NYql::TAstParseResult res = SqlToYql("insert into plato.Output (list0, list1) values (AsList(0, 1, 2), AsList(``));");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:73: Error: Column reference \"\" is not allowed in current scope\n");
+    }
+
+    Y_UNIT_TEST(EmptyAccess1) {
+        NYql::TAstParseResult res = SqlToYql("insert into plato.Output (list0, list1) values (AsList(0, 1, 2), ``);");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:66: Error: Column reference \"\" is not allowed in current scope\n");
+    }
+
+    Y_UNIT_TEST(UseUnknownColumnInInsert) {
+        NYql::TAstParseResult res = SqlToYql("insert into plato.Output (list0, list1) values (AsList(0, 1, 2), AsList(`test`));");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:73: Error: Column reference \"test\" is not allowed in current scope\n");
+    }
+
+    Y_UNIT_TEST(GroupByEmptyColumn) {
+        NYql::TAstParseResult res = SqlToYql("select count(1) from plato.Input group by ``;");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:43: Error: Column name can not be empty\n");
+    }
+
+    Y_UNIT_TEST(ConvertNumberOutOfBase) {
+        NYql::TAstParseResult res = SqlToYql("select 0o80l;");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:8: Error: Failed to parse number from string: 0o80l, char: '8' is out of base: 8\n");
+    }
+
+    Y_UNIT_TEST(ConvertNumberOutOfRangeForInt64ButFitsInUint64) {
+        NYql::TAstParseResult res = SqlToYql("select 0xc000000000000000l;");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:8: Error: Failed to parse 13835058055282163712 as integer literal of Int64 type: value out of range for Int64\n");
+    }
+
+    Y_UNIT_TEST(ConvertNumberOutOfRangeUint64) {
+        NYql::TAstParseResult res = SqlToYql("select 0xc0000000000000000l;");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:8: Error: Failed to parse number from string: 0xc0000000000000000l, number limit overflow\n");
+
+        res = SqlToYql("select 1234234543563435151456;\n");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:8: Error: Failed to parse number from string: 1234234543563435151456, number limit overflow\n");
+    }
+
+    Y_UNIT_TEST(ConvertNumberNegativeOutOfRange) {
+        NYql::TAstParseResult res = SqlToYql("select -9223372036854775808;\n"
+                                             "select -9223372036854775809;");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:2:8: Error: Failed to parse negative integer: -9223372036854775809, number limit overflow\n");
+    }
+
+    Y_UNIT_TEST(InvaildUsageReal0) {
+        NYql::TAstParseResult res = SqlToYql("select .0;");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_STRING_CONTAINS(Err2Str(res), "<main>:1:7: Error: extraneous input '.' expecting {");
+    }
+
+    Y_UNIT_TEST(InvaildUsageReal1) {
+        NYql::TAstParseResult res = SqlToYql("select .0f;");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_STRING_CONTAINS(Err2Str(res), "<main>:1:7: Error: extraneous input '.' expecting {");
+    }
+
+    Y_UNIT_TEST(InvaildUsageWinFunctionWithoutWindow) {
+        NYql::TAstParseResult res = SqlToYql("select lead(key, 2) from plato.Input;");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:8: Error: Failed to use window function Lead without window specification\n");
+    }
+
+    Y_UNIT_TEST(DropTableWithIfExists) {
+        NYql::TAstParseResult res = SqlToYql("DROP TABLE IF EXISTS plato.foo;");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("drop_if_exists"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(TooManyErrors) {
+        const char* q = R"(
+        USE plato;
+        select A, B, C, D, E, F, G, H, I, J, K, L, M, N from (select b from `abc`);
+)";
+
+        NYql::TAstParseResult res = SqlToYql(q, 10);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res),
+            R"(<main>:3:16: Error: Column A is not in source column set. Did you mean b?
+<main>:3:19: Error: Column B is not in source column set. Did you mean b?
+<main>:3:22: Error: Column C is not in source column set. Did you mean b?
+<main>:3:25: Error: Column D is not in source column set. Did you mean b?
+<main>:3:28: Error: Column E is not in source column set. Did you mean b?
+<main>:3:31: Error: Column F is not in source column set. Did you mean b?
+<main>:3:34: Error: Column G is not in source column set. Did you mean b?
+<main>:3:37: Error: Column H is not in source column set. Did you mean b?
+<main>:3:40: Error: Column I is not in source column set. Did you mean b?
+<main>: Error: Too many issues, code: 1
+)");
+    };
+
+    Y_UNIT_TEST(ShouldCloneBindingForNamedParameter) {
+        NYql::TAstParseResult res = SqlToYql(R"($f = () -> {
+    $value_type = TypeOf(1);
+    $pair_type = StructType(
+        TypeOf("2") AS key,
+        $value_type AS value
+    );
+
+    RETURN TupleType(
+        ListType($value_type),
+        $pair_type);
+};
+
+select FormatType($f());
+)");
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(BlockedInvalidFrameBounds) {
+        auto check = [](const TString& frame, const TString& err) {
+            const TString prefix = "SELECT SUM(x) OVER w FROM plato.Input WINDOW w AS (PARTITION BY key ORDER BY subkey\n";
+            NYql::TAstParseResult res = SqlToYql(prefix + frame + ")");
+            UNIT_ASSERT(!res.Root);
+            UNIT_ASSERT_NO_DIFF(Err2Str(res), err);
+        };
+
+        check("ROWS UNBOUNDED FOLLOWING", "<main>:2:5: Error: Frame cannot start from UNBOUNDED FOLLOWING\n");
+        check("ROWS BETWEEN 5 PRECEDING AND UNBOUNDED PRECEDING", "<main>:2:29: Error: Frame cannot end with UNBOUNDED PRECEDING\n");
+        check("ROWS BETWEEN CURRENT ROW AND 5 PRECEDING", "<main>:2:13: Error: Frame cannot start from CURRENT ROW and end with PRECEDING\n");
+        check("ROWS BETWEEN 5 FOLLOWING AND CURRENT ROW", "<main>:2:14: Error: Frame cannot start from FOLLOWING and end with CURRENT ROW\n");
+        check("ROWS BETWEEN 5 FOLLOWING AND 5 PRECEDING", "<main>:2:14: Error: Frame cannot start from FOLLOWING and end with PRECEDING\n");
+    }
+
+    Y_UNIT_TEST(BlockedRangeValueWithoutSingleOrderBy) {
+        UNIT_ASSERT(SqlToYql("SELECT COUNT(*) OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM plato.Input").IsOk());
+        UNIT_ASSERT(SqlToYql("SELECT COUNT(*) OVER (RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) FROM plato.Input").IsOk());
+
+        auto res = SqlToYql("SELECT COUNT(*) OVER (RANGE 5 PRECEDING) FROM plato.Input");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:29: Error: RANGE with <offset> PRECEDING/FOLLOWING requires exactly one expression in ORDER BY partition clause\n");
+
+        res = SqlToYql("SELECT COUNT(*) OVER (ORDER BY key, value RANGE 5 PRECEDING) FROM plato.Input");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:49: Error: RANGE with <offset> PRECEDING/FOLLOWING requires exactly one expression in ORDER BY partition clause\n");
+    }
+
+    Y_UNIT_TEST(NoColumnsInFrameBounds) {
+        NYql::TAstParseResult res = SqlToYql(
+            "SELECT SUM(x) OVER w FROM plato.Input WINDOW w AS (ROWS BETWEEN\n"
+            " 1 + key PRECEDING AND 2 + key FOLLOWING);");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:2:6: Error: Column reference \"key\" is not allowed in current scope\n");
+    }
+
+    Y_UNIT_TEST(WarnOnEmptyFrameBounds) {
+        NYql::TAstParseResult res = SqlToYql(
+            "SELECT SUM(x) OVER w FROM plato.Input WINDOW w AS (PARTITION BY key ORDER BY subkey\n"
+            "ROWS BETWEEN 10 FOLLOWING AND 5 FOLLOWING)");
+        UNIT_ASSERT(res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:2:14: Warning: Used frame specification implies empty window frame, code: 4520\n");
+    }
+
+    Y_UNIT_TEST(WarnOnRankWithUnorderedWindow) {
+        NYql::TAstParseResult res = SqlToYql("SELECT RANK() OVER w FROM plato.Input WINDOW w AS ()");
+        UNIT_ASSERT(res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:8: Warning: Rank() is used with unordered window - all rows will be considered equal to each other, code: 4521\n");
+    }
+
+    Y_UNIT_TEST(WarnOnRankExprWithUnorderedWindow) {
+        NYql::TAstParseResult res = SqlToYql("SELECT RANK(key) OVER w FROM plato.Input WINDOW w AS ()");
+        UNIT_ASSERT(res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:8: Warning: Rank(<expression>) is used with unordered window - the result is likely to be undefined, code: 4521\n");
+    }
+
+    Y_UNIT_TEST(AnyAsTableName) {
+        NYql::TAstParseResult res = SqlToYql("use plato; select * from any;");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:28: Error: no viable alternative at input 'any;'\n");
+    }
+
+    Y_UNIT_TEST(IncorrectOrderOfLambdaOptionalArgs) {
+        NYql::TAstParseResult res = SqlToYql("$f = ($x?, $y)->($x + $y); select $f(1);");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:12: Error: Non-optional argument can not follow optional one\n");
+    }
+
+    Y_UNIT_TEST(IncorrectOrderOfActionOptionalArgs) {
+        NYql::TAstParseResult res = SqlToYql("define action $f($x?, $y) as select $x,$y; end define; do $f(1);");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:23: Error: Non-optional argument can not follow optional one\n");
+    }
+
+    Y_UNIT_TEST(NotAllowedQuestionOnNamedNode) {
+        NYql::TAstParseResult res = SqlToYql("$f = 1; select $f?;");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:18: Error: Unexpected token '?' at the end of expression\n");
+    }
+
+    Y_UNIT_TEST(AnyAndCrossJoin) {
+        NYql::TAstParseResult res = SqlToYql("use plato; select * from any Input1 cross join Input2");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:26: Error: ANY should not be used with Cross JOIN\n");
+
+        res = SqlToYql("use plato; select * from Input1 cross join any Input2");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:44: Error: ANY should not be used with Cross JOIN\n");
+    }
+
+    Y_UNIT_TEST(AnyWithCartesianProduct) {
+        NYql::TAstParseResult res = SqlToYql("pragma AnsiImplicitCrossJoin; use plato; select * from any Input1, Input2");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:56: Error: ANY should not be used with Cross JOIN\n");
+
+        res = SqlToYql("pragma AnsiImplicitCrossJoin; use plato; select * from Input1, any Input2");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:64: Error: ANY should not be used with Cross JOIN\n");
+    }
+
+    Y_UNIT_TEST(ErrorPlainEndAsInlineActionTerminator) {
+        NYql::TAstParseResult res = SqlToYql(
+            "do begin\n"
+            "  select 1\n"
+            "; end\n");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:4:0: Error: missing DO at '<EOF>'\n");
+    }
+
+    Y_UNIT_TEST(ErrorMultiWayJoinWithUsing) {
+        NYql::TAstParseResult res = SqlToYql(
+            "USE plato;\n"
+            "PRAGMA DisableSimpleColumns;\n"
+            "SELECT *\n"
+            "FROM Input1 AS a\n"
+            "JOIN Input2 AS b USING(key)\n"
+            "JOIN Input3 AS c ON a.key = c.key;\n"
+        );
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res),
+            "<main>:5:24: Error: Multi-way JOINs should be connected with ON clause instead of USING clause\n"
+        );
+    }
+
+    Y_UNIT_TEST(RequireLabelInFlattenByWithDot) {
+        NYql::TAstParseResult res = SqlToYql("select * from plato.Input flatten by x.y");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res),
+            "<main>:1:40: Error: Unnamed expression after FLATTEN BY is not allowed\n"
+        );
+    }
+
+    Y_UNIT_TEST(WarnUnnamedColumns) {
+        NYql::TAstParseResult res = SqlToYql(
+            "PRAGMA WarnUnnamedColumns;\n"
+            "\n"
+            "SELECT key, subkey, key || subkey FROM plato.Input ORDER BY subkey;\n");
+        UNIT_ASSERT(res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:3:28: Warning: Autogenerated column name column2 will be used for expression, code: 4516\n");
+    }
+
+    Y_UNIT_TEST(WarnSourceColumnMismatch) {
+        NYql::TAstParseResult res = SqlToYql(
+            "insert into plato.Output (key, subkey, new_value, one_more_value) select key as Key, subkey, value, \"x\" from plato.Input;");
+        UNIT_ASSERT(res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:51: Warning: Column names in SELECT don't match column specification in parenthesis. \"key\" doesn't match \"Key\". \"new_value\" doesn't match \"value\", code: 4517\n");
+    }
+
+    Y_UNIT_TEST(YtCaseInsensitive) {
+        NYql::TAstParseResult res = SqlToYql("select * from PlatO.foo;");
+        UNIT_ASSERT(res.Root);
+
+        res = SqlToYql("use PlatO; select * from foo;");
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(KikimrCaseSensitive) {
+        NYql::TAstParseResult res = SqlToYql("select * from PlatO.foo;", 10, "kikimr");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:15: Error: Unknown cluster: PlatO\n");
+
+        res = SqlToYql("use PlatO; select * from foo;", 10, "kikimr");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:5: Error: Unknown cluster: PlatO\n");
+    }
+
+    Y_UNIT_TEST(DiscoveryModeForbidden) {
+        NYql::TAstParseResult res = SqlToYqlWithMode("insert into plato.Output select * from plato.range(\"\", Input1, Input4)", NSQLTranslation::ESqlMode::DISCOVERY);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:40: Error: range is not allowed in Discovery mode, code: 4600\n");
+
+        res = SqlToYqlWithMode("insert into plato.Output select * from plato.like(\"\", \"Input%\")", NSQLTranslation::ESqlMode::DISCOVERY);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:40: Error: like is not allowed in Discovery mode, code: 4600\n");
+
+        res = SqlToYqlWithMode("insert into plato.Output select * from plato.regexp(\"\", \"Input.\")", NSQLTranslation::ESqlMode::DISCOVERY);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:40: Error: regexp is not allowed in Discovery mode, code: 4600\n");
+
+        res = SqlToYqlWithMode("insert into plato.Output select * from plato.filter(\"\", ($name) -> { return find($name, \"Input\") is not null; })", NSQLTranslation::ESqlMode::DISCOVERY);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:40: Error: filter is not allowed in Discovery mode, code: 4600\n");
+
+        res = SqlToYqlWithMode("select Path from plato.folder(\"\") where Type == \"table\"", NSQLTranslation::ESqlMode::DISCOVERY);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:18: Error: folder is not allowed in Discovery mode, code: 4600\n");
+    }
+
+    Y_UNIT_TEST(YsonFuncWithoutArgs) {
+        UNIT_ASSERT(SqlToYql("SELECT Yson::SerializeText(Yson::From());").IsOk());
+    }
+
+    Y_UNIT_TEST(CanNotUseOrderByInNonLastSelectInUnionAllChain) {
+        auto req = "pragma AnsiOrderByLimitInUnionAll;\n"
+                   "use plato;\n"
+                   "\n"
+                   "select * from Input order by key\n"
+                   "union all\n"
+                   "select * from Input order by key limit 1;";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:4:21: Error: ORDER BY within UNION ALL is only allowed after last subquery\n");
+    }
+
+    Y_UNIT_TEST(CanNotUseLimitInNonLastSelectInUnionAllChain) {
+        auto req = "pragma AnsiOrderByLimitInUnionAll;\n"
+                   "use plato;\n"
+                   "\n"
+                   "select * from Input limit 1\n"
+                   "union all\n"
+                   "select * from Input order by key limit 1;";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:4:21: Error: LIMIT within UNION ALL is only allowed after last subquery\n");
+    }
+
+    Y_UNIT_TEST(CanNotUseDiscardInNonFirstSelectInUnionAllChain) {
+        auto req = "pragma AnsiOrderByLimitInUnionAll;\n"
+                   "use plato;\n"
+                   "\n"
+                   "select * from Input\n"
+                   "union all\n"
+                   "discard select * from Input;";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:6:1: Error: DISCARD within UNION ALL is only allowed before first subquery\n");
+    }
+
+    Y_UNIT_TEST(CanNotUseIntoResultInNonLastSelectInUnionAllChain) {
+        auto req = "use plato;\n"
+                   "pragma AnsiOrderByLimitInUnionAll;\n"
+                   "\n"
+                   "select * from Input\n"
+                   "union all\n"
+                   "discard select * from Input;";
+
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:6:1: Error: DISCARD within UNION ALL is only allowed before first subquery\n");
+    }
+
+    Y_UNIT_TEST(YsonStrictInvalidPragma) {
+        auto res = SqlToYql("pragma yson.Strict = \"wrong\";");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:22: Error: Expected 'true', 'false' or no parameter for: Strict\n");
+    }
+
+    Y_UNIT_TEST(WarnTableNameInSomeContexts) {
+        UNIT_ASSERT(SqlToYql("use plato; select TableName() from Input;").IsOk());
+        UNIT_ASSERT(SqlToYql("use plato; select TableName(\"aaaa\");").IsOk());
+        UNIT_ASSERT(SqlToYql("select TableName(\"aaaa\", \"yt\");").IsOk());
+
+        auto res = SqlToYql("select TableName() from plato.Input;");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:8: Error: TableName requires either service name as second argument or current cluster name\n");
+
+        res = SqlToYql("use plato;\n"
+                       "select TableName() from Input1 as a join Input2 as b using(key);");
+        UNIT_ASSERT(res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:2:8: Warning: TableName() may produce empty result when used in ambiguous context (with JOIN), code: 4525\n");
+
+        res = SqlToYql("use plato;\n"
+                       "select SOME(TableName()), key from Input group by key;");
+        UNIT_ASSERT(res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:2:13: Warning: TableName() will produce empty result when used with aggregation.\n"
+                                          "Please consult documentation for possible workaround, code: 4525\n");
+    }
+
+    Y_UNIT_TEST(WarnOnDistincWithHavingWithoutAggregations) {
+        auto res = SqlToYql("select distinct key from plato.Input having key != '0';");
+        UNIT_ASSERT(res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:49: Warning: The usage of HAVING without aggregations with SELECT DISTINCT is non-standard and will stop working soon. Please use WHERE instead., code: 4526\n");
+    }
+
+    Y_UNIT_TEST(FlattenByExprWithNestedNull) {
+        auto res = SqlToYql("USE plato;\n"
+                            "\n"
+                            "SELECT * FROM (SELECT 1 AS region_id)\n"
+                            "FLATTEN BY (\n"
+                            "    CAST($unknown(region_id) AS List<String>) AS region\n"
+                            ")");
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:5:10: Error: Unknown name: $unknown\n");
+    }
+
+    Y_UNIT_TEST(EmptySymbolNameIsForbidden) {
+        auto req = "    $`` = 1; select $``;";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:5: Error: Empty symbol name is not allowed\n");
+    }
+
+    Y_UNIT_TEST(WarnOnBinaryOpWithNullArg) {
+        auto req = "select * from plato.Input where cast(key as Int32) != NULL";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:52: Warning: Binary operation != will return NULL here, code: 4529\n");
+
+        req = "select 1 or null";
+        res = SqlToYql(req);
+        UNIT_ASSERT(res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "");
+    }
+
+    Y_UNIT_TEST(ErrorIfTableSampleArgUsesColumns) {
+        auto req = "SELECT key FROM plato.Input TABLESAMPLE BERNOULLI(MIN_OF(100.0, CAST(subkey as Int32)));";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:70: Error: Column reference \"subkey\" is not allowed in current scope\n");
+    }
+
+    Y_UNIT_TEST(DerivedColumnListForSelectIsNotSupportedYet) {
+        auto req = "SELECT a,b,c FROM plato.Input as t(x,y,z);";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:35: Error: Derived column list is only supported for VALUES\n");
+    }
+
+    Y_UNIT_TEST(ErrorIfValuesHasDifferentCountOfColumns) {
+        auto req = "VALUES (1,2,3), (4,5);";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:17: Error: All VALUES items should have same size: expecting 3, got 2\n");
+    }
+
+    Y_UNIT_TEST(ErrorIfDerivedColumnSizeExceedValuesColumnCount) {
+        auto req = "SELECT * FROM(VALUES (1,2), (3,4)) as t(x,y,z);";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:40: Error: Derived column list size exceeds column count in VALUES\n");
+    }
+
+    Y_UNIT_TEST(WarnoOnAutogeneratedNamesForValues) {
+        auto req = "PRAGMA WarnUnnamedColumns;\n"
+                   "SELECT * FROM (VALUES (1,2,3,4), (5,6,7,8)) as t(x,y);";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:2:16: Warning: Autogenerated column names column2...column3 will be used here, code: 4516\n");
+    }
+
+    Y_UNIT_TEST(ErrUnionAllWithOrderByWithoutExplicitLegacyMode) {
+        auto req = "use plato;\n"
+                   "\n"
+                   "select * from Input order by key\n"
+                   "union all\n"
+                   "select * from Input order by key;";
+
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:3:21: Error: ORDER BY within UNION ALL is only allowed after last subquery\n");
+    }
+
+    Y_UNIT_TEST(ErrUnionAllWithLimitWithoutExplicitLegacyMode) {
+        auto req = "use plato;\n"
+                   "\n"
+                   "select * from Input limit 10\n"
+                   "union all\n"
+                   "select * from Input limit 1;";
+
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:3:21: Error: LIMIT within UNION ALL is only allowed after last subquery\n");
+    }
+
+    Y_UNIT_TEST(ErrUnionAllWithIntoResultWithoutExplicitLegacyMode) {
+        auto req = "use plato;\n"
+                   "\n"
+                   "select * from Input into result aaa\n"
+                   "union all\n"
+                   "select * from Input;";
+
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:3:21: Error: INTO RESULT within UNION ALL is only allowed after last subquery\n");
+    }
+
+    Y_UNIT_TEST(ErrUnionAllWithDiscardWithoutExplicitLegacyMode) {
+        auto req = "use plato;\n"
+                   "\n"
+                   "select * from Input\n"
+                   "union all\n"
+                   "discard select * from Input;";
+
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:5:1: Error: DISCARD within UNION ALL is only allowed before first subquery\n");
+    }
+
+    Y_UNIT_TEST(ErrUnionAllKeepsIgnoredOrderByWarning) {
+        auto req = "use plato;\n"
+                   "\n"
+                   "SELECT * FROM (\n"
+                   "  SELECT * FROM Input\n"
+                   "  UNION ALL\n"
+                   "  SELECT t.* FROM Input AS t ORDER BY t.key\n"
+                   ");";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:4:3: Warning: ORDER BY without LIMIT in subquery will be ignored, code: 4504\n"
+                                          "<main>:6:39: Error: Unknown correlation name: t\n");
+    }
+
+    Y_UNIT_TEST(InvalidTtlInterval) {
+        auto req = R"(
+            USE plato;
+            CREATE TABLE tableName (Key Uint32, CreatedAt Timestamp, PRIMARY KEY (Key))
+            WITH (TTL = 1 On CreatedAt);
+        )";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:4:25: Error: Literal of Interval type is expected for TTL\n"
+                                          "<main>:4:25: Error: Invalid TTL settings\n");
+    }
+
+    Y_UNIT_TEST(InvalidTtlUnit) {
+        auto req = R"(
+            USE plato;
+            CREATE TABLE tableName (Key Uint32, CreatedAt Uint32, PRIMARY KEY (Key))
+            WITH (TTL = Interval("P1D") On CreatedAt AS PICOSECONDS);
+        )";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_STRING_CONTAINS(Err2Str(res), "mismatched input 'PICOSECONDS' expecting {MICROSECONDS, MILLISECONDS, NANOSECONDS, SECONDS}");
+    }
+
+    Y_UNIT_TEST(InvalidChangefeedSink) {
+        auto req = R"(
+            USE plato;
+            CREATE TABLE tableName (
+                Key Uint32, PRIMARY KEY (Key),
+                CHANGEFEED feedName WITH (SINK_TYPE = "S3", MODE = "KEYS_ONLY", FORMAT = "json")
+            );
+        )";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:5:55: Error: Unknown changefeed sink type: S3\n");
+    }
+
+    Y_UNIT_TEST(InvalidChangefeedSettings) {
+        auto req = R"(
+            USE plato;
+            CREATE TABLE tableName (
+                Key Uint32, PRIMARY KEY (Key),
+                CHANGEFEED feedName WITH (SINK_TYPE = "local", FOO = "bar")
+            );
+        )";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:5:64: Error: Unknown changefeed setting: FOO\n");
+    }
+
+    Y_UNIT_TEST(InvalidChangefeedInitialScan) {
+        auto req = R"(
+            USE plato;
+            CREATE TABLE tableName (
+                Key Uint32, PRIMARY KEY (Key),
+                CHANGEFEED feedName WITH (MODE = "KEYS_ONLY", FORMAT = "json", INITIAL_SCAN = "foo")
+            );
+        )";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:5:95: Error: Literal of Bool type is expected for INITIAL_SCAN\n");
+    }
+
+    Y_UNIT_TEST(InvalidChangefeedVirtualTimestamps) {
+        auto req = R"(
+            USE plato;
+            CREATE TABLE tableName (
+                Key Uint32, PRIMARY KEY (Key),
+                CHANGEFEED feedName WITH (MODE = "KEYS_ONLY", FORMAT = "json", VIRTUAL_TIMESTAMPS = "foo")
+            );
+        )";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:5:101: Error: Literal of Bool type is expected for VIRTUAL_TIMESTAMPS\n");
+    }
+
+    Y_UNIT_TEST(InvalidChangefeedResolvedTimestamps) {
+        auto req = R"(
+            USE plato;
+            CREATE TABLE tableName (
+                Key Uint32, PRIMARY KEY (Key),
+                CHANGEFEED feedName WITH (MODE = "KEYS_ONLY", FORMAT = "json", RESOLVED_TIMESTAMPS = "foo")
+            );
+        )";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:5:102: Error: Literal of Interval type is expected for RESOLVED_TIMESTAMPS\n");
+    }
+
+    Y_UNIT_TEST(InvalidChangefeedRetentionPeriod) {
+        auto req = R"(
+            USE plato;
+            CREATE TABLE tableName (
+                Key Uint32, PRIMARY KEY (Key),
+                CHANGEFEED feedName WITH (MODE = "KEYS_ONLY", FORMAT = "json", RETENTION_PERIOD = "foo")
+            );
+        )";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:5:99: Error: Literal of Interval type is expected for RETENTION_PERIOD\n");
+    }
+
+    Y_UNIT_TEST(InvalidChangefeedTopicPartitions) {
+        auto req = R"(
+            USE plato;
+            CREATE TABLE tableName (
+                Key Uint32, PRIMARY KEY (Key),
+                CHANGEFEED feedName WITH (MODE = "KEYS_ONLY", FORMAT = "json", TOPIC_MIN_ACTIVE_PARTITIONS = "foo")
+            );
+        )";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:5:110: Error: Literal of integer type is expected for TOPIC_MIN_ACTIVE_PARTITIONS\n");
+    }
+
+    Y_UNIT_TEST(InvalidChangefeedAwsRegion) {
+        auto req = R"(
+            USE plato;
+            CREATE TABLE tableName (
+                Key Uint32, PRIMARY KEY (Key),
+                CHANGEFEED feedName WITH (MODE = "KEYS_ONLY", FORMAT = "json", AWS_REGION = true)
+            );
+        )";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:5:93: Error: Literal of String type is expected for AWS_REGION\n");
+    }
+
+    Y_UNIT_TEST(ErrJoinWithGroupingSetsWithoutCorrelationName) {
+        auto req = "USE plato;\n"
+                   "\n"
+                   "SELECT k1, k2, subkey\n"
+                   "FROM T1 AS a JOIN T2 AS b USING (key)\n"
+                   "GROUP BY GROUPING SETS(\n"
+                   "  (a.key as k1, b.subkey as k2),\n"
+                   "  (k1),\n"
+                   "  (subkey)\n"
+                   ");";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:8:4: Error: Columns in grouping sets should have correlation name, error in key: subkey\n");
+    }
+
+    Y_UNIT_TEST(ErrJoinWithGroupByWithoutCorrelationName) {
+        auto req = "USE plato;\n"
+                   "\n"
+                   "SELECT k1, k2,\n"
+                   "    value\n"
+                   "FROM T1 AS a JOIN T2 AS b USING (key)\n"
+                   "GROUP BY a.key as k1, b.subkey as k2,\n"
+                   "    value;";
+        ExpectFailWithError(req,
+            "<main>:7:5: Error: Columns in GROUP BY should have correlation name, error in key: value\n");
+    }
+
+    Y_UNIT_TEST(ErrWithMissingFrom) {
+        auto req = "select 1 as key where 1 > 1;";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:25: Error: Filtering is not allowed without FROM\n");
+
+        req = "select 1 + count(*);";
+        res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:12: Error: Aggregation is not allowed without FROM\n");
+
+        req = "select 1 as key, subkey + value;";
+        res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:1: Error: Column references are not allowed without FROM\n"
+                                          "<main>:1:18: Error: Column reference 'subkey'\n"
+                                          "<main>:1:1: Error: Column references are not allowed without FROM\n"
+                                          "<main>:1:27: Error: Column reference 'value'\n");
+
+        req = "select count(1) group by key;";
+        res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:1: Error: Column references are not allowed without FROM\n"
+                                          "<main>:1:26: Error: Column reference 'key'\n");
+    }
+
+    Y_UNIT_TEST(ErrWithMissingFromForWindow) {
+        auto req = "$c = () -> (1 + count(1) over w);\n"
+                   "select $c();";
+        ExpectFailWithError(req,
+            "<main>:1:9: Error: Window and aggregation functions are not allowed in this context\n"
+            "<main>:1:17: Error: Failed to use aggregation function Count without window specification or in wrong place\n");
+
+        req = "$c = () -> (1 + lead(1) over w);\n"
+              "select $c();";
+        ExpectFailWithError(req,
+            "<main>:1:17: Error: Window functions are not allowed in this context\n"
+            "<main>:1:17: Error: Failed to use window function Lead without window specification or in wrong place\n");
+
+        req = "select 1 + count(1) over w window w as ();";
+        ExpectFailWithError(req,
+            "<main>:1:1: Error: Window and aggregation functions are not allowed without FROM\n"
+            "<main>:1:12: Error: Failed to use aggregation function Count without window specification or in wrong place\n");
+
+        req = "select 1 + lead(1) over w window w as ();";
+        ExpectFailWithError(req,
+            "<main>:1:12: Error: Window functions are not allowed without FROM\n"
+            "<main>:1:12: Error: Failed to use window function Lead without window specification or in wrong place\n");
+    }
+
+    Y_UNIT_TEST(ErrWithMissingFromForInplaceWindow) {
+        auto req = "$c = () -> (1 + count(1) over ());\n"
+                   "select $c();";
+        ExpectFailWithError(req,
+            "<main>:1:26: Error: Window and aggregation functions are not allowed in this context\n");
+
+        req = "$c = () -> (1 + lead(1) over (rows between unbounded preceding and current row));\n"
+              "select $c();";
+        ExpectFailWithError(req,
+            "<main>:1:25: Error: Window and aggregation functions are not allowed in this context\n");
+
+        req = "select 1 + count(1) over ();";
+        ExpectFailWithError(req,
+            "<main>:1:1: Error: Window and aggregation functions are not allowed without FROM\n"
+            "<main>:1:12: Error: Failed to use aggregation function Count without window specification or in wrong place\n");
+
+        req = "select 1 + lead(1) over (rows between current row and unbounded following);";
+        ExpectFailWithError(req,
+            "<main>:1:12: Error: Window functions are not allowed without FROM\n"
+            "<main>:1:12: Error: Failed to use window function Lead without window specification or in wrong place\n");
+    }
+
+    Y_UNIT_TEST(ErrDistinctInWrongPlace) {
+        auto req = "select Some::Udf(distinct key) from plato.Input;";
+        ExpectFailWithError(req,
+            "<main>:1:18: Error: DISTINCT can only be used in aggregation functions\n");
+        req = "select sum(key)(distinct foo) from plato.Input;";
+        ExpectFailWithError(req,
+            "<main>:1:17: Error: DISTINCT can only be used in aggregation functions\n");
+
+        req = "select len(distinct foo) from plato.Input;";
+        ExpectFailWithError(req,
+            "<main>:1:8: Error: DISTINCT can only be used in aggregation functions\n");
+
+        req = "$foo = ($x) -> ($x); select $foo(distinct key) from plato.Input;";
+        ExpectFailWithError(req,
+            "<main>:1:34: Error: DISTINCT can only be used in aggregation functions\n");
+    }
+
+    Y_UNIT_TEST(ErrForNotSingleChildInInlineAST) {
+        ExpectFailWithError("select YQL::\"\"",
+            "<main>:1:8: Error: Failed to parse YQL: expecting AST root node with single child, but got 0\n");
+        ExpectFailWithError("select YQL::@@  \t@@",
+            "<main>:1:8: Error: Failed to parse YQL: expecting AST root node with single child, but got 0\n");
+        auto req = "$lambda = YQL::@@(lambda '(x)(+ x x)) (lambda '(y)(+ y y))@@;\n"
+                   "select ListMap([1, 2, 3], $lambda);";
+        ExpectFailWithError(req,
+            "<main>:1:11: Error: Failed to parse YQL: expecting AST root node with single child, but got 2\n");
+    }
+
+    Y_UNIT_TEST(ErrEmptyColumnName) {
+        ExpectFailWithError("select * without \"\" from plato.Input",
+            "<main>:1:18: Error: String literal can not be used here\n");
+
+        ExpectFailWithError("select * without `` from plato.Input;",
+            "<main>:1:18: Error: Empty column name is not allowed\n");
+
+        ExpectFailWithErrorForAnsiLexer("select * without \"\" from plato.Input",
+            "<main>:1:18: Error: Empty column name is not allowed\n");
+
+        ExpectFailWithErrorForAnsiLexer("select * without `` from plato.Input;",
+            "<main>:1:18: Error: Empty column name is not allowed\n");
+    }
+
+    Y_UNIT_TEST(ErrOnNonZeroArgumentsForTableRows) {
+        ExpectFailWithError("$udf=\"\";process plato.Input using $udf(TableRows(k))",
+            "<main>:1:40: Error: TableRows requires exactly 0 arguments\n");
+    }
+
+    Y_UNIT_TEST(ErrGroupByWithAggregationFunctionAndDistinctExpr) {
+        ExpectFailWithError("select * from plato.Input group by count(distinct key|key)",
+            "<main>:1:36: Error: Unable to GROUP BY aggregated values\n");
+    }
+
+    // FIXME: check if we can get old behaviour
+#if 0
+    Y_UNIT_TEST(ErrWithSchemaWithColumnsWithoutType) {
+        ExpectFailWithError("select * from plato.Input with COLUMNs",
+            "<main>:1:32: Error: Expected type after COLUMNS\n"
+            "<main>:1:32: Error: Failed to parse table hints\n");
+
+        ExpectFailWithError("select * from plato.Input with scheMa",
+            "<main>:1:32: Error: Expected type after SCHEMA\n"
+            "<main>:1:32: Error: Failed to parse table hints\n");
+    }
+#endif
+
+    Y_UNIT_TEST(ErrCollectPreaggregatedInListLiteralWithoutFrom) {
+        ExpectFailWithError("SELECT([VARIANCE(DISTINCT[])])",
+            "<main>:1:1: Error: Column references are not allowed without FROM\n"
+            "<main>:1:9: Error: Column reference '_yql_preagg_Variance0'\n");
+    }
+
+    Y_UNIT_TEST(ErrGroupBySmartParenAsTuple) {
+        ExpectFailWithError("SELECT * FROM plato.Input GROUP BY (k, v,)",
+            "<main>:1:41: Error: Unexpected trailing comma in grouping elements list\n");
+    }
+
+    Y_UNIT_TEST(HandleNestedSmartParensInGroupBy) {
+        ExpectFailWithError("SELECT * FROM plato.Input GROUP BY (+() as k)",
+            "<main>:1:37: Error: Unable to GROUP BY constant expression\n");
+    }
+
+    Y_UNIT_TEST(ErrRenameWithAddColumn) {
+        ExpectFailWithError("USE plato; ALTER TABLE table RENAME TO moved, ADD COLUMN addc uint64",
+                            "<main>:1:40: Error: RENAME TO can not be used together with another table action\n");
+    }
+
+    Y_UNIT_TEST(ErrAddColumnAndRename) {
+        // FIXME: fix positions in ALTER TABLE
+        ExpectFailWithError("USE plato; ALTER TABLE table ADD COLUMN addc uint64, RENAME TO moved",
+                            "<main>:1:46: Error: RENAME TO can not be used together with another table action\n");
+    }
+
+    Y_UNIT_TEST(InvalidUuidValue) {
+        ExpectFailWithError("SELECT Uuid('123e4567ae89ba12d3aa456a426614174ab0')",
+                            "<main>:1:8: Error: Invalid value \"123e4567ae89ba12d3aa456a426614174ab0\" for type Uuid\n");
+        ExpectFailWithError("SELECT Uuid('123e4567ae89b-12d3-a456-426614174000')",
+                            "<main>:1:8: Error: Invalid value \"123e4567ae89b-12d3-a456-426614174000\" for type Uuid\n");
+    }
+
+    Y_UNIT_TEST(WindowFunctionWithoutOver) {
+        ExpectFailWithError("SELECT LAST_VALUE(foo) FROM plato.Input",
+                            "<main>:1:8: Error: Can't use window function LastValue without window specification (OVER keyword is missing)\n");
+        ExpectFailWithError("SELECT LAST_VALUE(foo) FROM plato.Input GROUP BY key",
+                            "<main>:1:8: Error: Can't use window function LastValue without window specification (OVER keyword is missing)\n");
+    }
+
+    Y_UNIT_TEST(CreateAlterUserWithoutCluster) {
+        ExpectFailWithError("\n CREATE USER user ENCRYPTED PASSWORD 'foobar';", "<main>:2:2: Error: USE statement is missing - no default cluster is selected\n");
+        ExpectFailWithError("ALTER USER CURRENT_USER RENAME TO $foo;", "<main>:1:1: Error: USE statement is missing - no default cluster is selected\n");
+    }
+
+    Y_UNIT_TEST(ModifyPermissionsWithoutCluster) {
+        ExpectFailWithError("\n GRANT CONNECT ON `/Root` TO user;", "<main>:2:2: Error: USE statement is missing - no default cluster is selected\n");
+        ExpectFailWithError("\n REVOKE MANAGE ON `/Root` FROM user;", "<main>:2:2: Error: USE statement is missing - no default cluster is selected\n");
+    }
+
+    Y_UNIT_TEST(ReservedRoleNames) {
+        ExpectFailWithError("USE plato; CREATE USER current_User;", "<main>:1:24: Error: System role CURRENT_USER can not be used here\n");
+        ExpectFailWithError("USE plato; ALTER USER current_User RENAME TO Current_role", "<main>:1:46: Error: System role CURRENT_ROLE can not be used here\n");
+        UNIT_ASSERT(SqlToYql("USE plato; DROP GROUP IF EXISTS a, b, c, current_User;").IsOk());
+    }
+
+    Y_UNIT_TEST(DisableClassicDivisionWithError) {
+        ExpectFailWithError("pragma ClassicDivision = 'false'; select $foo / 30;", "<main>:1:42: Error: Unknown name: $foo\n");
+    }
+
+    Y_UNIT_TEST(AggregationOfAgrregatedDistinctExpr) {
+        ExpectFailWithError("select sum(sum(distinct x + 1)) from plato.Input", "<main>:1:12: Error: Aggregation of aggregated values is forbidden\n");
+    }
+
+    Y_UNIT_TEST(WarnForUnusedSqlHint) {
+        NYql::TAstParseResult res = SqlToYql("select * from plato.Input1 as a join /*+ merge() */ plato.Input2 as b using(key);\n"
+                                             "select --+            foo(bar)\n"
+                                             "       1;");
+        UNIT_ASSERT(res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:2:23: Warning: Hint foo will not be used, code: 4534\n");
+    }
+
+    Y_UNIT_TEST(WarnForDeprecatedSchema) {
+        NSQLTranslation::TTranslationSettings settings;
+        settings.ClusterMapping["s3bucket"] = NYql::S3ProviderName;
+        NYql::TAstParseResult res = SqlToYql("select * from s3bucket.`foo` with schema (col1 Int32, String as col2, Int64 as col3);", settings);
+        UNIT_ASSERT(res.Root);
+        UNIT_ASSERT_STRING_CONTAINS(res.Issues.ToString(), "Warning: Deprecated syntax for positional schema: please use 'column type' instead of 'type AS column', code: 4535\n");
+    }
+
+    Y_UNIT_TEST(ErrorOnColumnNameInMaxByLimit) {
+        ExpectFailWithError(
+            "SELECT AGGREGATE_BY(AsTuple(value, key), AggregationFactory(\"MAX_BY\", subkey)) FROM plato.Input;",
+            "<main>:1:42: Error: Source does not allow column references\n"
+            "<main>:1:71: Error: Column reference 'subkey'\n");
+    }
+
+    Y_UNIT_TEST(ErrorInLibraryWithTopLevelNamedSubquery) {
+        TString withUnusedSubq = "$unused = select max(key) from plato.Input;\n"
+                                 "\n"
+                                 "define subquery $foo() as\n"
+                                 "  $count = select count(*) from plato.Input;\n"
+                                 "  select * from plato.Input limit $count / 2;\n"
+                                 "end define;\n"
+                                 "export $foo;\n";
+        UNIT_ASSERT(SqlToYqlWithMode(withUnusedSubq, NSQLTranslation::ESqlMode::LIBRARY).IsOk());
+
+        TString withTopLevelSubq = "$count = select count(*) from plato.Input;\n"
+                                   "\n"
+                                   "define subquery $foo() as\n"
+                                   "  select * from plato.Input limit $count / 2;\n"
+                                   "end define;\n"
+                                   "export $foo;\n";
+        auto res = SqlToYqlWithMode(withTopLevelSubq, NSQLTranslation::ESqlMode::LIBRARY);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:17: Error: Named subquery can not be used as a top level statement in libraries\n");
+    }
+
+    Y_UNIT_TEST(SessionStartAndSessionStateShouldSurviveSessionWindowArgsError){
+        TString query = R"(
+            $init = ($_row) -> (min(1, 2)); -- error: aggregation func min() can not be used here
+            $calculate = ($_row, $_state) -> (1);
+            $update = ($_row, $_state) -> (2);
+            SELECT
+                SessionStart() over w as session_start,
+                SessionState() over w as session_state,
+            FROM plato.Input as t
+            WINDOW w AS (
+                PARTITION BY user, SessionWindow(ts + 1, $init, $update, $calculate)
+            )
+        )";
+        ExpectFailWithError(query, "<main>:2:33: Error: Aggregation function Min requires exactly 1 argument(s), given: 2\n");
+    }
+}
+
+void CheckUnused(const TString& req, const TString& symbol, unsigned row, unsigned col) {
+    auto res = SqlToYql(req);
+
+    UNIT_ASSERT(res.Root);
+    UNIT_ASSERT_NO_DIFF(Err2Str(res), TStringBuilder() << "<main>:" << row << ":" << col << ": Warning: Symbol " << symbol << " is not used, code: 4527\n");
+}
+
+Y_UNIT_TEST_SUITE(WarnUnused) {
+    Y_UNIT_TEST(ActionOrSubquery) {
+        TString req = "  $a()\n"
+                      "as select 1;\n"
+                      "end define;\n"
+                      "\n"
+                      "select 1;";
+        CheckUnused("define action\n" + req, "$a", 2, 3);
+        CheckUnused("define subquery\n" + req, "$a", 2, 3);
+    }
+
+    Y_UNIT_TEST(Import) {
+        TString req = "import lib1 symbols\n"
+                      "  $sqr;\n"
+                      "select 1;";
+        CheckUnused(req, "$sqr", 2, 3);
+
+        req = "import lib1 symbols\n"
+              "  $sqr as\n"
+              "    $sq;\n"
+              "select 1;";
+        CheckUnused(req, "$sq", 3, 5);
+    }
+
+    Y_UNIT_TEST(NamedNodeStatement) {
+        TString req = " $a, $a = AsTuple(1, 2);\n"
+                      "select $a;";
+        CheckUnused(req, "$a", 1, 2);
+        req = "$a,  $b = AsTuple(1, 2);\n"
+              "select $a;";
+        CheckUnused(req, "$b", 1, 6);
+        CheckUnused(" $a = 1; $a = 2; select $a;", "$a", 1, 2);
+    }
+
+    Y_UNIT_TEST(Declare) {
+        CheckUnused("declare $a as String;select 1;", "$a", 1, 9);
+    }
+
+    Y_UNIT_TEST(ActionParams) {
+        TString req = "define action $a($x, $y) as\n"
+                      "  select $x;\n"
+                      "end define;\n"
+                      "\n"
+                      "do $a(1,2);";
+        CheckUnused(req, "$y", 1, 22);
+    }
+
+    Y_UNIT_TEST(SubqueryParams) {
+        TString req = "use plato;\n"
+                      "define subquery $q($name, $x) as\n"
+                      "  select * from $name;\n"
+                      "end define;\n"
+                      "\n"
+                      "select * from $q(\"Input\", 1);";
+        CheckUnused(req, "$x", 2, 27);
+    }
+
+    Y_UNIT_TEST(For) {
+        TString req = "define action $a() as\n"
+                      "  select 1;\n"
+                      "end define;\n"
+                      "\n"
+                      "for $i in ListFromRange(1, 10)\n"
+                      "do $a();";
+        CheckUnused(req, "$i", 5, 5);
+    }
+
+    Y_UNIT_TEST(LambdaParams) {
+        TString req = "$lambda = ($x, $y) -> ($x);\n"
+                      "select $lambda(1, 2);";
+        CheckUnused(req, "$y", 1, 16);
+    }
+
+    Y_UNIT_TEST(InsideLambdaBody) {
+        TString req = "$lambda = () -> {\n"
+                      "  $x = 1; return 1;\n"
+                      "};\n"
+                      "select $lambda();";
+        CheckUnused(req, "$x", 2, 3);
+        req = "$lambda = () -> {\n"
+              "  $x = 1; $x = 2; return $x;\n"
+              "};\n"
+              "select $lambda();";
+        CheckUnused(req, "$x", 2, 3);
+    }
+
+    Y_UNIT_TEST(InsideAction) {
+        TString req = "define action $a() as\n"
+                      "  $x = 1; select 1;\n"
+                      "end define;\n"
+                      "\n"
+                      "do $a();";
+        CheckUnused(req, "$x", 2, 3);
+        req = "define action $a() as\n"
+              "  $x = 1; $x = 2; select $x;\n"
+              "end define;\n"
+              "\n"
+              "do $a();";
+        CheckUnused(req, "$x", 2, 3);
+    }
+
+    Y_UNIT_TEST(NoWarnOnNestedActions) {
+        auto req = "pragma warning(\"error\", \"4527\");\n"
+                   "define action $action($b) as\n"
+                   "    define action $aaa() as\n"
+                   "        select $b;\n"
+                   "    end define;\n"
+                   "    do $aaa();\n"
+                   "end define;\n"
+                   "\n"
+                   "do $action(1);";
+        UNIT_ASSERT(SqlToYql(req).IsOk());
+    }
+
+    Y_UNIT_TEST(NoWarnForUsageAfterSubquery) {
+        auto req = "use plato;\n"
+                   "pragma warning(\"error\", \"4527\");\n"
+                   "\n"
+                   "$a = 1;\n"
+                   "\n"
+                   "define subquery $q($table) as\n"
+                   "  select * from $table;\n"
+                   "end define;\n"
+                   "\n"
+                   "select * from $q(\"Input\");\n"
+                   "select $a;";
+        UNIT_ASSERT(SqlToYql(req).IsOk());
+    }
+}
+
+Y_UNIT_TEST_SUITE(AnonymousNames) {
+    Y_UNIT_TEST(ReferenceAnonymousVariableIsForbidden) {
+        auto req = "$_ = 1; select $_;";
+
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:16: Error: Unable to reference anonymous name $_\n");
+
+        req = "$`_` = 1; select $`_`;";
+        res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:18: Error: Unable to reference anonymous name $_\n");
+    }
+
+    Y_UNIT_TEST(Declare) {
+        auto req = "declare $_ as String;";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:9: Error: Can not use anonymous name '$_' in DECLARE statement\n");
+    }
+
+    Y_UNIT_TEST(ActionSubquery) {
+        auto req = "define action $_() as select 1; end define;";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:15: Error: Can not use anonymous name '$_' as ACTION name\n");
+
+        req = "define subquery $_() as select 1; end define;";
+        res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:17: Error: Can not use anonymous name '$_' as SUBQUERY name\n");
+    }
+
+    Y_UNIT_TEST(Import) {
+        auto req = "import lib symbols $sqr as $_;";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:28: Error: Can not import anonymous name $_\n");
+    }
+
+    Y_UNIT_TEST(Export) {
+        auto req = "export $_;";
+        auto res = SqlToYqlWithMode(req, NSQLTranslation::ESqlMode::LIBRARY);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:8: Error: Can not export anonymous name $_\n");
+    }
+
+    Y_UNIT_TEST(AnonymousInActionArgs) {
+        auto req = "pragma warning(\"error\", \"4527\");\n"
+                   "define action $a($_, $y, $_) as\n"
+                   "  select $y;\n"
+                   "end define;\n"
+                   "\n"
+                   "do $a(1,2,3);";
+        UNIT_ASSERT(SqlToYql(req).IsOk());
+    }
+
+    Y_UNIT_TEST(AnonymousInSubqueryArgs) {
+        auto req = "use plato;\n"
+                   "pragma warning(\"error\", \"4527\");\n"
+                   "define subquery $q($_, $y, $_) as\n"
+                   "  select * from $y;\n"
+                   "end define;\n"
+                   "\n"
+                   "select * from $q(1,\"Input\",3);";
+        UNIT_ASSERT(SqlToYql(req).IsOk());
+    }
+
+    Y_UNIT_TEST(AnonymousInLambdaArgs) {
+        auto req = "pragma warning(\"error\", \"4527\");\n"
+                   "$lambda = ($_, $x, $_) -> ($x);\n"
+                   "select $lambda(1,2,3);";
+        UNIT_ASSERT(SqlToYql(req).IsOk());
+    }
+
+    Y_UNIT_TEST(AnonymousInFor) {
+        auto req = "pragma warning(\"error\", \"4527\");\n"
+                   "evaluate for $_ in ListFromRange(1, 10) do begin select 1; end do;";
+        UNIT_ASSERT(SqlToYql(req).IsOk());
+    }
+
+    Y_UNIT_TEST(Assignment) {
+        auto req = "pragma warning(\"error\", \"4527\");\n"
+                   "$_ = 1;\n"
+                   "$_, $x, $_ = AsTuple(1,2,3);\n"
+                   "select $x;";
+        UNIT_ASSERT(SqlToYql(req).IsOk());
+    }
+}
+
+Y_UNIT_TEST_SUITE(JsonValue) {
+    Y_UNIT_TEST(JsonValueArgumentCount) {
+        NYql::TAstParseResult res = SqlToYql("select JSON_VALUE(CAST(@@{\"key\": 1238}@@ as Json));");
+
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:49: Error: mismatched input ')' expecting ','\n");
+    }
+
+    Y_UNIT_TEST(JsonValueJsonPathMustBeLiteralString) {
+        NYql::TAstParseResult res = SqlToYql("$jsonPath = \"strict $.key\"; select JSON_VALUE(CAST(@@{\"key\": 1238}@@ as Json), $jsonPath);");
+
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:79: Error: mismatched input '$' expecting STRING_VALUE\n");
+    }
+
+    Y_UNIT_TEST(JsonValueTranslation) {
+        NYql::TAstParseResult res = SqlToYql("select JSON_VALUE(CAST(@@{\"key\": 1238}@@ as Json), \"strict $.key\");");
+
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            Y_UNUSED(word);
+            UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("'\"strict $.key\""));
+            UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("SafeCast"));
+            UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("DataType 'Json"));
+        };
+
+        TWordCountHive elementStat({"JsonValue"});
+        VerifyProgram(res, elementStat, verifyLine);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["JsonValue"]);
+    }
+
+    Y_UNIT_TEST(JsonValueReturningSection) {
+        for (const auto& typeName : {"Bool", "Int64", "Double", "String"}) {
+            NYql::TAstParseResult res = SqlToYql(
+                TStringBuilder() << "select JSON_VALUE(CAST(@@{\"key\": 1238}@@ as Json), \"strict $.key\" RETURNING " << typeName << ");"
+            );
+
+            UNIT_ASSERT(res.Root);
+
+            TVerifyLineFunc verifyLine = [&](const TString& word, const TString& line) {
+                Y_UNUSED(word);
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("'\"strict $.key\""));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("SafeCast"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("DataType 'Json"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(TStringBuilder() << "DataType '" << typeName));
+            };
+
+            TWordCountHive elementStat({typeName});
+            VerifyProgram(res, elementStat, verifyLine);
+            UNIT_ASSERT(elementStat[typeName] > 0);
+        }
+    }
+
+    Y_UNIT_TEST(JsonValueInvalidReturningType) {
+        NYql::TAstParseResult res = SqlToYql("select JSON_VALUE(CAST(@@{'key': 1238}@@ as Json), 'strict $.key' RETURNING invalid);");
+
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:77: Error: Unknown simple type 'invalid'\n");
+    }
+
+    Y_UNIT_TEST(JsonValueAndReturningInExpressions) {
+        NYql::TAstParseResult res = SqlToYql(
+            "USE plato\n;"
+            "$json_value = \"some string\";\n"
+            "SELECT $json_value;\n"
+            "SELECT 1 as json_value;\n"
+            "SELECT $json_value as json_value;\n"
+            "$returning = \"another string\";\n"
+            "SELECT $returning;\n"
+            "SELECT 1 as returning;\n"
+            "SELECT $returning as returning;\n"
+        );
+
+        UNIT_ASSERT(res.Root);
+    }
+
+    Y_UNIT_TEST(JsonValueValidCaseHandlers) {
+        const TVector<std::pair<TString, TString>> testCases = {
+            {"", "'DefaultValue (Null)"},
+            {"NULL", "'DefaultValue (Null)"},
+            {"ERROR", "'Error (Null)"},
+            {"DEFAULT 123", "'DefaultValue (Int32 '\"123\")"},
+        };
+
+        for (const auto& onEmpty : testCases) {
+            for (const auto& onError : testCases) {
+                TStringBuilder query;
+                query << "$json = CAST(@@{\"key\": 1238}@@ as Json);\n"
+                    << "SELECT JSON_VALUE($json, \"strict $.key\"";
+                if (!onEmpty.first.Empty()) {
+                    query << " " << onEmpty.first << " ON EMPTY";
+                }
+                if (!onError.first.Empty()) {
+                    query << " " << onError.first << " ON ERROR";
+                }
+                query << ");\n";
+
+                NYql::TAstParseResult res = SqlToYql(query);
+
+                UNIT_ASSERT(res.Root);
+
+                TVerifyLineFunc verifyLine = [&](const TString& word, const TString& line) {
+                    Y_UNUSED(word);
+                    UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(onEmpty.second + " " + onError.second));
+                };
+
+                TWordCountHive elementStat({"JsonValue"});
+                VerifyProgram(res, elementStat, verifyLine);
+                UNIT_ASSERT(elementStat["JsonValue"] > 0);
+            }
+        }
+    }
+
+    Y_UNIT_TEST(JsonValueTooManyCaseHandlers) {
+        NYql::TAstParseResult res = SqlToYql(
+            "select JSON_VALUE(CAST(@@{\"key\": 1238}@@ as Json), \"strict $.key\" NULL ON EMPTY NULL ON ERROR NULL ON EMPTY);\n"
+        );
+
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(
+            Err2Str(res),
+            "<main>:1:52: Error: Only 1 ON EMPTY and/or 1 ON ERROR clause is expected\n"
+        );
+    }
+
+    Y_UNIT_TEST(JsonValueTooManyOnEmpty) {
+        NYql::TAstParseResult res = SqlToYql(
+            "select JSON_VALUE(CAST(@@{\"key\": 1238}@@ as Json), \"strict $.key\" NULL ON EMPTY NULL ON EMPTY);\n"
+        );
+
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(
+            Err2Str(res),
+            "<main>:1:52: Error: Only 1 ON EMPTY clause is expected\n"
+        );
+    }
+
+    Y_UNIT_TEST(JsonValueTooManyOnError) {
+        NYql::TAstParseResult res = SqlToYql(
+            "select JSON_VALUE(CAST(@@{\"key\": 1238}@@ as Json), \"strict $.key\" NULL ON ERROR NULL ON ERROR);\n"
+        );
+
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(
+            Err2Str(res),
+            "<main>:1:52: Error: Only 1 ON ERROR clause is expected\n"
+        );
+    }
+
+    Y_UNIT_TEST(JsonValueOnEmptyAfterOnError) {
+        NYql::TAstParseResult res = SqlToYql(
+            "select JSON_VALUE(CAST(@@{\"key\": 1238}@@ as Json), \"strict $.key\" NULL ON ERROR NULL ON EMPTY);\n"
+        );
+
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(
+            Err2Str(res),
+            "<main>:1:52: Error: ON EMPTY clause must be before ON ERROR clause\n"
+        );
+    }
+
+    Y_UNIT_TEST(JsonValueNullInput) {
+        NYql::TAstParseResult res = SqlToYql(R"(SELECT JSON_VALUE(NULL, "strict $.key");)");
+
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [&](const TString& word, const TString& line) {
+            Y_UNUSED(word);
+            UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("(Nothing (OptionalType (DataType 'Json)))"));
+        };
+
+        TWordCountHive elementStat({"JsonValue"});
+        VerifyProgram(res, elementStat, verifyLine);
+        UNIT_ASSERT(elementStat["JsonValue"] > 0);
+    }
+}
+
+Y_UNIT_TEST_SUITE(JsonExists) {
+    Y_UNIT_TEST(JsonExistsValidHandlers) {
+        const TVector<std::pair<TString, TString>> testCases = {
+            {"", "(Just (Bool '\"false\"))"},
+            {"TRUE ON ERROR", "(Just (Bool '\"true\"))"},
+            {"FALSE ON ERROR", "(Just (Bool '\"false\"))"},
+            {"UNKNOWN ON ERROR", "(Nothing (OptionalType (DataType 'Bool)))"},
+            // NOTE: in this case we expect arguments of JsonExists callable to end immediately
+            // after variables. This parenthesis at the end of the expression is left on purpose
+            {"ERROR ON ERROR", "(Utf8 '\"strict $.key\") (JsonVariables))"},
+        };
+
+        for (const auto& item : testCases) {
+            NYql::TAstParseResult res = SqlToYql(
+                TStringBuilder() << R"(
+                $json = CAST(@@{"key": 1238}@@ as Json);
+                SELECT JSON_EXISTS($json, "strict $.key" )" << item.first << ");\n"
+            );
+
+            UNIT_ASSERT(res.Root);
+
+            TVerifyLineFunc verifyLine = [&](const TString& word, const TString& line) {
+                Y_UNUSED(word);
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(item.second));
+            };
+
+            TWordCountHive elementStat({"JsonExists"});
+            VerifyProgram(res, elementStat, verifyLine);
+            UNIT_ASSERT(elementStat["JsonExists"] > 0);
+        }
+    }
+
+    Y_UNIT_TEST(JsonExistsInvalidHandler) {
+        NYql::TAstParseResult res = SqlToYql(R"(
+            $json = CAST(@@{"key": 1238}@@ as Json);
+            $default = false;
+            SELECT JSON_EXISTS($json, "strict $.key" $default ON ERROR);
+        )");
+
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:4:53: Error: mismatched input '$' expecting {')', ERROR, FALSE, TRUE, UNKNOWN}\n");
+    }
+
+    Y_UNIT_TEST(JsonExistsNullInput) {
+        NYql::TAstParseResult res = SqlToYql(R"(SELECT JSON_EXISTS(NULL, "strict $.key");)");
+
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [&](const TString& word, const TString& line) {
+            Y_UNUSED(word);
+            UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("(Nothing (OptionalType (DataType 'Json)))"));
+        };
+
+        TWordCountHive elementStat({"JsonExists"});
+        VerifyProgram(res, elementStat, verifyLine);
+        UNIT_ASSERT(elementStat["JsonExists"] > 0);
+    }
+}
+
+Y_UNIT_TEST_SUITE(JsonQuery) {
+    Y_UNIT_TEST(JsonQueryValidHandlers) {
+        using TTestSuite = const TVector<std::pair<TString, TString>>;
+        TTestSuite wrapCases = {
+            {"", "'NoWrap"},
+            {"WITHOUT WRAPPER", "'NoWrap"},
+            {"WITHOUT ARRAY WRAPPER", "'NoWrap"},
+            {"WITH WRAPPER", "'Wrap"},
+            {"WITH ARRAY WRAPPER", "'Wrap"},
+            {"WITH UNCONDITIONAL WRAPPER", "'Wrap"},
+            {"WITH UNCONDITIONAL ARRAY WRAPPER", "'Wrap"},
+            {"WITH CONDITIONAL WRAPPER", "'ConditionalWrap"},
+            {"WITH CONDITIONAL ARRAY WRAPPER", "'ConditionalWrap"},
+        };
+        TTestSuite handlerCases = {
+            {"", "'Null"},
+            {"ERROR", "'Error"},
+            {"NULL", "'Null"},
+            {"EMPTY ARRAY", "'EmptyArray"},
+            {"EMPTY OBJECT", "'EmptyObject"},
+        };
+
+        for (const auto& wrap : wrapCases) {
+            for (const auto& onError : handlerCases) {
+                for (const auto& onEmpty : handlerCases) {
+                    TStringBuilder query;
+                    query << R"($json = CAST(@@{"key": [123]}@@ as Json);
+                    SELECT JSON_QUERY($json, "strict $.key" )" << wrap.first;
+                    if (!onEmpty.first.Empty()) {
+                        if (wrap.first.StartsWith("WITH ")) {
+                            continue;
+                        }
+                        query << " " << onEmpty.first << " ON EMPTY";
+                    }
+                    if (!onError.first.Empty()) {
+                        query << " " << onError.first << " ON ERROR";
+                    }
+                    query << ");\n";
+
+                    NYql::TAstParseResult res = SqlToYql(query);
+
+                    UNIT_ASSERT(res.Root);
+
+                    TVerifyLineFunc verifyLine = [&](const TString& word, const TString& line) {
+                        Y_UNUSED(word);
+                        const TString args = TStringBuilder() << wrap.second << " " << onEmpty.second << " " << onError.second;
+                        UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(args));
+                    };
+
+                    Cout << wrap.first << " " << onEmpty.first << " " << onError.first << Endl;
+
+                    TWordCountHive elementStat({"JsonQuery"});
+                    VerifyProgram(res, elementStat, verifyLine);
+                    UNIT_ASSERT(elementStat["JsonQuery"] > 0);
+                }
+            }
+        }
+    }
+
+    Y_UNIT_TEST(JsonQueryOnEmptyWithWrapper) {
+        NYql::TAstParseResult res = SqlToYql(R"(
+            $json = CAST(@@{"key": 1238}@@ as Json);
+            SELECT JSON_QUERY($json, "strict $" WITH ARRAY WRAPPER EMPTY ARRAY ON EMPTY);
+        )");
+
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:3:38: Error: ON EMPTY is prohibited because WRAPPER clause is specified\n");
+    }
+
+    Y_UNIT_TEST(JsonQueryNullInput) {
+        NYql::TAstParseResult res = SqlToYql(R"(SELECT JSON_QUERY(NULL, "strict $.key");)");
+
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [&](const TString& word, const TString& line) {
+            Y_UNUSED(word);
+            UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("(Nothing (OptionalType (DataType 'Json)))"));
+        };
+
+        TWordCountHive elementStat({"JsonQuery"});
+        VerifyProgram(res, elementStat, verifyLine);
+        UNIT_ASSERT(elementStat["JsonQuery"] > 0);
+    }
+}
+
+Y_UNIT_TEST_SUITE(JsonPassing) {
+    Y_UNIT_TEST(SupportedVariableTypes) {
+        const TVector<TString> functions = {"JSON_EXISTS", "JSON_VALUE", "JSON_QUERY"};
+
+        for (const auto& function : functions) {
+            const auto query = Sprintf(R"(
+                pragma CompactNamedExprs;
+                $json = CAST(@@{"key": 1238}@@ as Json);
+                SELECT %s(
+                    $json,
+                    "strict $.key"
+                    PASSING
+                        "string" as var1,
+                        1.234 as var2,
+                        CAST(1 as Int64) as var3,
+                        true as var4,
+                        $json as var5
+                ))",
+                function.data()
+            );
+            NYql::TAstParseResult res = SqlToYql(query);
+
+            UNIT_ASSERT(res.Root);
+
+            TVerifyLineFunc verifyLine = [&](const TString& word, const TString& line) {
+                Y_UNUSED(word);
+                UNIT_ASSERT_VALUES_UNEQUAL_C(TString::npos, line.find(R"('('"var1" (String '"string")))"), "Cannot find `var1`");
+                UNIT_ASSERT_VALUES_UNEQUAL_C(TString::npos, line.find(R"('('"var2" (Double '"1.234")))"), "Cannot find `var2`");
+                UNIT_ASSERT_VALUES_UNEQUAL_C(TString::npos, line.find(R"('('"var3" (SafeCast (Int32 '"1") (DataType 'Int64))))"), "Cannot find `var3`");
+                UNIT_ASSERT_VALUES_UNEQUAL_C(TString::npos, line.find(R"('('"var4" (Bool '"true")))"), "Cannot find `var4`");
+                UNIT_ASSERT_VALUES_UNEQUAL_C(TString::npos, line.find(R"('('"var5" namedexprnode0))"), "Cannot find `var5`");
+            };
+
+            TWordCountHive elementStat({"JsonVariables"});
+            VerifyProgram(res, elementStat, verifyLine);
+            UNIT_ASSERT(elementStat["JsonVariables"] > 0);
+        }
+    }
+
+    Y_UNIT_TEST(ValidVariableNames) {
+        const TVector<TString> functions = {"JSON_EXISTS", "JSON_VALUE", "JSON_QUERY"};
+
+        for (const auto& function : functions) {
+            const auto query = Sprintf(R"(
+                $json = CAST(@@{"key": 1238}@@ as Json);
+                SELECT %s(
+                    $json,
+                    "strict $.key"
+                    PASSING
+                        "one" as var1,
+                        "two" as "VaR2",
+                        "three" as `var3`,
+                        "four" as VaR4
+                ))",
+                function.data()
+            );
+            NYql::TAstParseResult res = SqlToYql(query);
+
+            UNIT_ASSERT(res.Root);
+
+            TVerifyLineFunc verifyLine = [&](const TString& word, const TString& line) {
+                Y_UNUSED(word);
+                UNIT_ASSERT_VALUES_UNEQUAL_C(TString::npos, line.find(R"('('"var1" (String '"one")))"), "Cannot find `var1`");
+                UNIT_ASSERT_VALUES_UNEQUAL_C(TString::npos, line.find(R"('('"VaR2" (String '"two")))"), "Cannot find `VaR2`");
+                UNIT_ASSERT_VALUES_UNEQUAL_C(TString::npos, line.find(R"('('"var3" (String '"three")))"), "Cannot find `var3`");
+                UNIT_ASSERT_VALUES_UNEQUAL_C(TString::npos, line.find(R"('('"VaR4" (String '"four")))"), "Cannot find `VaR4`");
+            };
+
+            TWordCountHive elementStat({"JsonVariables"});
+            VerifyProgram(res, elementStat, verifyLine);
+            UNIT_ASSERT(elementStat["JsonVariables"] > 0);
+        }
+    }
+}
+
+Y_UNIT_TEST_SUITE(MigrationToJsonApi) {
+    Y_UNIT_TEST(WarningOnDeprecatedJsonUdf) {
+        NYql::TAstParseResult res = SqlToYql(R"(
+            $json = CAST(@@{"key": 1234}@@ as Json);
+            SELECT Json::Parse($json);
+        )");
+
+        UNIT_ASSERT(res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:3:26: Warning: Json UDF is deprecated. Please use JSON API instead, code: 4506\n");
+    }
+}
+
+Y_UNIT_TEST_SUITE(AnsiIdentsNegative) {
+    Y_UNIT_TEST(EnableAnsiLexerFromRequestSpecialComments) {
+        auto req = "\n"
+                   "\t --!ansi_lexer \n"
+                   "-- Some comment\n"
+                   "-- another comment\n"
+                   "pragma SimpleColumns;\n"
+                   "\n"
+                   "select 1, '''' as empty;";
+
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(res.IsOk());
+        UNIT_ASSERT(res.Issues.Size() == 0);
+    }
+
+    Y_UNIT_TEST(AnsiLexerShouldNotBeEnabledHere) {
+        auto req = "$str = '\n"
+                   "--!ansi_lexer\n"
+                   "--!syntax_v1\n"
+                   "';\n"
+                   "\n"
+                   "select 1, $str, \"\" as empty;";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(res.IsOk());
+        UNIT_ASSERT(res.Issues.Size() == 0);
+    }
+
+    Y_UNIT_TEST(DoubleQuotesInDictsTuplesOrLists) {
+        auto req = "$d = { 'a': 1, \"b\": 2, 'c': 3,};";
+
+        auto res = SqlToYqlWithAnsiLexer(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:16: Error: Column reference \"b\" is not allowed in current scope\n");
+
+        req = "$t = (1, 2, \"a\");";
+
+        res = SqlToYqlWithAnsiLexer(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:13: Error: Column reference \"a\" is not allowed in current scope\n");
+
+        req = "$l = ['a', 'b', \"c\"];";
+
+        res = SqlToYqlWithAnsiLexer(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:17: Error: Column reference \"c\" is not allowed in current scope\n");
+    }
+
+    Y_UNIT_TEST(MultilineComments) {
+        auto req = "/*/**/ select 1;";
+        auto res = SqlToYql(req);
+        UNIT_ASSERT(res.Root);
+        res = SqlToYqlWithAnsiLexer(req);
+        UNIT_ASSERT(res.IsOk());
+        UNIT_ASSERT(res.Issues.Size() == 0);
+
+        req = "/*\n"
+              "--/*\n"
+              "*/ select 1;";
+        res = SqlToYql(req);
+        UNIT_ASSERT(res.Root);
+        res = SqlToYqlWithAnsiLexer(req);
+        UNIT_ASSERT(res.IsOk());
+        UNIT_ASSERT(res.Issues.Size() == 0);
+
+        req = "/*\n"
+              "/*\n"
+              "--*/\n"
+              "*/ select 1;";
+        res = SqlToYql(req);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:4:0: Error: mismatched input '*' expecting {';', '(', '$', ALTER, ANALYZE, COMMIT, CREATE, DECLARE, DEFINE, DELETE, DISCARD, DO, DROP, EVALUATE, EXPLAIN, EXPORT, FOR, FROM, GRANT, IF, IMPORT, INSERT, PARALLEL, PRAGMA, PROCESS, REDUCE, REPLACE, REVOKE, ROLLBACK, SELECT, UPDATE, UPSERT, USE, VALUES}\n");
+        res = SqlToYqlWithAnsiLexer(req);
+        UNIT_ASSERT(res.Root);
+    }
+}
+
+Y_UNIT_TEST_SUITE(AnsiOptionalAs) {
+    Y_UNIT_TEST(OptionalAsInProjection) {
+        UNIT_ASSERT(SqlToYql("PRAGMA AnsiOptionalAs; SELECT a b, c FROM plato.Input;").IsOk());
+        ExpectFailWithError("PRAGMA DisableAnsiOptionalAs;\n"
+                            "SELECT a b, c FROM plato.Input;",
+                            "<main>:2:10: Error: Expecting mandatory AS here. Did you miss comma? Please add PRAGMA AnsiOptionalAs; for ANSI compatibility\n");
+    }
+
+    Y_UNIT_TEST(OptionalAsWithKeywords) {
+        UNIT_ASSERT(SqlToYql("PRAGMA AnsiOptionalAs; SELECT a type, b data, c source FROM plato.Input;").IsOk());
+    }
+}
+
+Y_UNIT_TEST_SUITE(SessionWindowNegative) {
+    Y_UNIT_TEST(SessionWindowWithoutSource) {
+        ExpectFailWithError("SELECT 1 + SessionWindow(ts, 32);",
+            "<main>:1:12: Error: SessionWindow requires data source\n");
+    }
+
+    Y_UNIT_TEST(SessionWindowInProjection) {
+        ExpectFailWithError("SELECT 1 + SessionWindow(ts, 32) from plato.Input;",
+            "<main>:1:12: Error: SessionWindow can only be used as a top-level GROUP BY / PARTITION BY expression\n");
+    }
+
+    Y_UNIT_TEST(SessionWindowWithNonConstSecondArg) {
+        ExpectFailWithError(
+            "SELECT key, session_start FROM plato.Input\n"
+            "GROUP BY SessionWindow(ts, 32 + subkey) as session_start, key;",
+
+            "<main>:2:10: Error: Source does not allow column references\n"
+            "<main>:2:33: Error: Column reference 'subkey'\n");
+    }
+
+    Y_UNIT_TEST(SessionWindowWithWrongNumberOfArgs) {
+        ExpectFailWithError("SELECT * FROM plato.Input GROUP BY SessionWindow()",
+            "<main>:1:36: Error: SessionWindow requires either two or four arguments\n");
+        ExpectFailWithError("SELECT * FROM plato.Input GROUP BY SessionWindow(key, subkey, 100)",
+            "<main>:1:36: Error: SessionWindow requires either two or four arguments\n");
+    }
+
+    Y_UNIT_TEST(DuplicateSessionWindow) {
+        ExpectFailWithError(
+            "SELECT\n"
+            "    *\n"
+            "FROM plato.Input\n"
+            "GROUP BY\n"
+            "    SessionWindow(ts, 10),\n"
+            "    user,\n"
+            "    SessionWindow(ts, 20)\n"
+            ";",
+
+            "<main>:7:5: Error: Duplicate session window specification:\n"
+            "<main>:5:5: Error: Previous session window is declared here\n");
+
+        ExpectFailWithError(
+            "SELECT\n"
+            "    MIN(key) over w\n"
+            "FROM plato.Input\n"
+            "WINDOW w AS (\n"
+            "    PARTITION BY SessionWindow(ts, 10), user,\n"
+            "    SessionWindow(ts, 20)\n"
+            ");",
+
+            "<main>:6:5: Error: Duplicate session window specification:\n"
+            "<main>:5:18: Error: Previous session window is declared here\n");
+    }
+
+    Y_UNIT_TEST(SessionStartStateWithoutSource) {
+        ExpectFailWithError("SELECT 1 + SessionStart();",
+            "<main>:1:12: Error: SessionStart requires data source\n");
+        ExpectFailWithError("SELECT 1 + SessionState();",
+            "<main>:1:12: Error: SessionState requires data source\n");
+    }
+
+    Y_UNIT_TEST(SessionStartStateWithoutGroupByOrWindow) {
+        ExpectFailWithError("SELECT 1 + SessionStart() from plato.Input;",
+            "<main>:1:12: Error: SessionStart can not be used without aggregation by SessionWindow\n");
+        ExpectFailWithError("SELECT 1 + SessionState() from plato.Input;",
+            "<main>:1:12: Error: SessionState can not be used without aggregation by SessionWindow\n");
+    }
+
+    Y_UNIT_TEST(SessionStartStateWithGroupByWithoutSession) {
+        ExpectFailWithError("SELECT 1 + SessionStart() from plato.Input group by user;",
+            "<main>:1:12: Error: SessionStart can not be used here: SessionWindow specification is missing in GROUP BY\n");
+        ExpectFailWithError("SELECT 1 + SessionState() from plato.Input group by user;",
+            "<main>:1:12: Error: SessionState can not be used here: SessionWindow specification is missing in GROUP BY\n");
+    }
+
+    Y_UNIT_TEST(SessionStartStateWithoutOverWithWindowWithoutSession) {
+        ExpectFailWithError("SELECT 1 + SessionStart(), MIN(key) over w from plato.Input window w as ()",
+            "<main>:1:12: Error: SessionStart can not be used without aggregation by SessionWindow. Maybe you forgot to add OVER `window_name`?\n");
+        ExpectFailWithError("SELECT 1 + SessionState(), MIN(key) over w from plato.Input window w as ()",
+            "<main>:1:12: Error: SessionState can not be used without aggregation by SessionWindow. Maybe you forgot to add OVER `window_name`?\n");
+    }
+
+    Y_UNIT_TEST(SessionStartStateWithWindowWithoutSession) {
+        ExpectFailWithError("SELECT 1 + SessionStart() over w, MIN(key) over w from plato.Input window w as ()",
+            "<main>:1:12: Error: SessionStart can not be used with window w: SessionWindow specification is missing in PARTITION BY\n");
+        ExpectFailWithError("SELECT 1 + SessionState() over w, MIN(key) over w from plato.Input window w as ()",
+            "<main>:1:12: Error: SessionState can not be used with window w: SessionWindow specification is missing in PARTITION BY\n");
+    }
+
+    Y_UNIT_TEST(SessionStartStateWithSessionedWindow) {
+        ExpectFailWithError("SELECT 1 + SessionStart(), MIN(key) over w from plato.Input group by key window w as (partition by SessionWindow(ts, 1)) ",
+            "<main>:1:12: Error: SessionStart can not be used here: SessionWindow specification is missing in GROUP BY. Maybe you forgot to add OVER `window_name`?\n");
+        ExpectFailWithError("SELECT 1 + SessionState(), MIN(key) over w from plato.Input group by key window w as (partition by SessionWindow(ts, 1)) ",
+            "<main>:1:12: Error: SessionState can not be used here: SessionWindow specification is missing in GROUP BY. Maybe you forgot to add OVER `window_name`?\n");
+    }
+
+    Y_UNIT_TEST(AggregationBySessionStateIsNotSupportedYet) {
+        ExpectFailWithError("SELECT SOME(1 + SessionState()), key from plato.Input group by key, SessionWindow(ts, 1);",
+            "<main>:1:17: Error: SessionState with GROUP BY is not supported yet\n");
+    }
+
+    Y_UNIT_TEST(SessionWindowInRtmr) {
+        NYql::TAstParseResult res = SqlToYql(
+            "SELECT * FROM plato.Input GROUP BY SessionWindow(ts, 10);",
+            10, TString(NYql::RtmrProviderName));
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:1:54: Error: Streaming group by query must have a hopping window specification.\n");
+
+        res = SqlToYql(R"(
+            SELECT key, SUM(value) AS value FROM plato.Input
+            GROUP BY key, HOP(subkey, "PT10S", "PT30S", "PT20S"), SessionWindow(ts, 10);
+        )", 10, TString(NYql::RtmrProviderName));
+
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res), "<main>:2:13: Error: SessionWindow is unsupported for streaming sources\n");
+    }
+}
+
+Y_UNIT_TEST_SUITE(LibraSqlSugar) {
+    auto makeResult = [](TStringBuf settings) {
+        return SqlToYql(
+            TStringBuilder()
+                << settings
+                << "\n$udf1 = MyLibra::MakeLibraPreprocessor($settings);"
+                << "\n$udf2 = CustomLibra::MakeLibraPreprocessor($settings);"
+                << "\nPROCESS plato.Input USING $udf1(TableRow())"
+                << "\nUNION ALL"
+                << "\nPROCESS plato.Input USING $udf2(TableRow());"
+        );
+    };
+
+    Y_UNIT_TEST(EmptySettings) {
+        auto res = makeResult(R"(
+            $settings = AsStruct();
+        )");
+        UNIT_ASSERT(res.IsOk());
+    }
+
+    Y_UNIT_TEST(OnlyEntities) {
+        auto res = makeResult(R"(
+            $settings = AsStruct(
+                AsList("A", "B", "C") AS Entities
+            );
+        )");
+        UNIT_ASSERT(res.IsOk());
+    }
+
+    Y_UNIT_TEST(EntitiesWithStrategy) {
+        auto res = makeResult(R"(
+            $settings = AsStruct(
+                AsList("A", "B", "C") AS Entities,
+                "blacklist" AS EntitiesStrategy
+            );
+        )");
+        UNIT_ASSERT(res.IsOk());
+    }
+
+    Y_UNIT_TEST(AllSettings) {
+        auto res = makeResult(R"(
+            $settings = AsStruct(
+                AsList("A", "B", "C") AS Entities,
+                "whitelist" AS EntitiesStrategy,
+                "path" AS BlockstatDict,
+                false AS ParseWithFat,
+                "map" AS Mode
+            );
+        )");
+        UNIT_ASSERT(res.IsOk());
+    }
+
+    Y_UNIT_TEST(BadStrategy) {
+        auto res = makeResult(R"(
+            $settings = AsStruct("bad" AS EntitiesStrategy);
+        )");
+        UNIT_ASSERT_STRING_CONTAINS(
+            Err2Str(res),
+            "Error: MakeLibraPreprocessor got invalid entities strategy: expected 'whitelist' or 'blacklist'"
+        );
+    }
+
+    Y_UNIT_TEST(BadEntities) {
+        auto res = makeResult(R"(
+            $settings = AsStruct(AsList("A", 1) AS Entities);
+        )");
+        UNIT_ASSERT_STRING_CONTAINS(Err2Str(res), "Error: MakeLibraPreprocessor entity must be string literal");
+    }
+}
+
+Y_UNIT_TEST_SUITE(TrailingQuestionsNegative) {
+    Y_UNIT_TEST(Basic) {
+        ExpectFailWithError("SELECT 1?;", "<main>:1:9: Error: Unexpected token '?' at the end of expression\n");
+        ExpectFailWithError("SELECT 1? + 1;", "<main>:1:10: Error: mismatched input '+' expecting {<EOF>, ';'}\n");
+        ExpectFailWithError("SELECT 1 + 1??? < 2", "<main>:1:13: Error: Unexpected token '?' at the end of expression\n");
+        ExpectFailWithError("SELECT   1? > 2? > 3?",
+            "<main>:1:11: Error: Unexpected token '?' at the end of expression\n"
+            "<main>:1:16: Error: Unexpected token '?' at the end of expression\n"
+            "<main>:1:21: Error: Unexpected token '?' at the end of expression\n");
+    }
+
+    Y_UNIT_TEST(SmartParen) {
+        ExpectFailWithError("$x = 1; SELECT (Int32?, $x?)", "<main>:1:27: Error: Unexpected token '?' at the end of expression\n");
+        ExpectFailWithError("SELECT (Int32, foo?)", "<main>:1:19: Error: Unexpected token '?' at the end of expression\n");
+    }
+
+    Y_UNIT_TEST(LambdaOptArgs) {
+        ExpectFailWithError("$l = ($x, $y?, $z??, $t?) -> ($x);", "<main>:1:18: Error: Expecting at most one '?' token here (for optional lambda parameters), but got 2\n");
+    }
+}
+
+Y_UNIT_TEST_SUITE(FlexibleTypes) {
+    Y_UNIT_TEST(AssumeOrderByType) {
+        UNIT_ASSERT(SqlToYql("PRAGMA FlexibleTypes; SELECT 1 AS int32 ASSUME ORDER BY int32").IsOk());
+    }
+
+    Y_UNIT_TEST(GroupingSets) {
+        UNIT_ASSERT(SqlToYql("PRAGMA FlexibleTypes; SELECT COUNT(*) AS cnt, text, uuid FROM plato.Input GROUP BY GROUPING SETS((uuid), (uuid, text));").IsOk());
+    }
+
+    Y_UNIT_TEST(WeakField) {
+        UNIT_ASSERT(SqlToYql("PRAGMA FlexibleTypes; SELECT WeakField(text, string) as text FROM plato.Input").IsOk());
+    }
+
+    Y_UNIT_TEST(Aggregation1) {
+        TString q =
+            "PRAGMA FlexibleTypes;\n"
+            "$foo = ($x, $const, $type) -> ($x || $const || FormatType($type));\n"
+            "SELECT $foo(SOME(x), 'aaa', String) FROM plato.Input GROUP BY y;";
+        UNIT_ASSERT(SqlToYql(q).IsOk());
+    }
+
+    Y_UNIT_TEST(Aggregation2) {
+        TString q =
+            "PRAGMA FlexibleTypes;\n"
+            "SELECT 1 + String + MAX(key) FROM plato.Input;";
+        UNIT_ASSERT(SqlToYql(q).IsOk());
+    }
+}
+
+Y_UNIT_TEST_SUITE(ExternalDeclares) {
+    Y_UNIT_TEST(BasicUsage) {
+        NSQLTranslation::TTranslationSettings settings;
+        settings.DeclaredNamedExprs["foo"] = "String";
+        auto res = SqlToYqlWithSettings("select $foo;", settings);
+        UNIT_ASSERT(res.IsOk());
+        UNIT_ASSERT(res.Issues.Size() == 0);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "declare") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(R"__((declare "$foo" (DataType 'String)))__"));
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("declare"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["declare"]);
+    }
+
+    Y_UNIT_TEST(DeclareOverrides) {
+        NSQLTranslation::TTranslationSettings settings;
+        settings.DeclaredNamedExprs["foo"] = "String";
+        auto res = SqlToYqlWithSettings("declare $foo as Int32; select $foo;", settings);
+        UNIT_ASSERT(res.IsOk());
+        UNIT_ASSERT(res.Issues.Size() == 0);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "declare") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(R"__((declare "$foo" (DataType 'Int32)))__"));
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("declare"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["declare"]);
+    }
+
+    Y_UNIT_TEST(UnusedDeclareDoesNotProduceWarning) {
+        NSQLTranslation::TTranslationSettings settings;
+        settings.DeclaredNamedExprs["foo"] = "String";
+        auto res = SqlToYqlWithSettings("select 1;", settings);
+        UNIT_ASSERT(res.IsOk());
+        UNIT_ASSERT(res.Issues.Size() == 0);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "declare") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(R"__((declare "$foo" (DataType 'String)))__"));
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("declare"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["declare"]);
+    }
+
+    Y_UNIT_TEST(DeclaresWithInvalidTypesFails) {
+        NSQLTranslation::TTranslationSettings settings;
+        settings.DeclaredNamedExprs["foo"] = "List<BadType>";
+        auto res = SqlToYqlWithSettings("select 1;", settings);
+        UNIT_ASSERT(!res.Root);
+        UNIT_ASSERT_NO_DIFF(Err2Str(res),
+            "<main>:0:5: Error: Unknown type: 'BadType'\n"
+            "<main>: Error: Failed to parse type for externally declared name 'foo'\n");
+    }
+}
+
+Y_UNIT_TEST_SUITE(ExternalDataSource) {
+    Y_UNIT_TEST(CreateExternalDataSourceWithAuthNone) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+                USE plato;
+                CREATE EXTERNAL DATA SOURCE MyDataSource WITH (
+                    SOURCE_TYPE="ObjectStorage",
+                    LOCATION="my-bucket",
+                    AUTH_METHOD="NONE"
+                );
+            )sql");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#('('('"auth_method" '"NONE") '('"location" '"my-bucket") '('"source_type" '"ObjectStorage"))#");
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("createObject"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(CreateExternalDataSourceWithAuthServiceAccount) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+                USE plato;
+                CREATE EXTERNAL DATA SOURCE MyDataSource WITH (
+                    SOURCE_TYPE="ObjectStorage",
+                    LOCATION="my-bucket",
+                    AUTH_METHOD="SERVICE_ACCOUNT",
+                    SERVICE_ACCOUNT_ID="sa",
+                    SERVICE_ACCOUNT_SECRET_NAME="sa_secret_name"
+                );
+            )sql");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#('('('"auth_method" '"SERVICE_ACCOUNT") '('"location" '"my-bucket") '('"service_account_id" '"sa") '('"service_account_secret_name" '"sa_secret_name") '('"source_type" '"ObjectStorage"))#");
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("createObject"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(CreateExternalDataSourceWithBasic) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+                USE plato;
+                CREATE EXTERNAL DATA SOURCE MyDataSource WITH (
+                    SOURCE_TYPE="PostgreSQL",
+                    LOCATION="protocol://host:port/",
+                    AUTH_METHOD="BASIC",
+                    LOGIN="admin",
+                    PASSWORD_SECRET_NAME="secret_name"
+                );
+            )sql");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#('('('"auth_method" '"BASIC") '('"location" '"protocol://host:port/") '('"login" '"admin") '('"password_secret_name" '"secret_name") '('"source_type" '"PostgreSQL"))#");
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("createObject"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(CreateExternalDataSourceWithMdbBasic) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+                USE plato;
+                CREATE EXTERNAL DATA SOURCE MyDataSource WITH (
+                    SOURCE_TYPE="PostgreSQL",
+                    LOCATION="protocol://host:port/",
+                    AUTH_METHOD="MDB_BASIC",
+                    SERVICE_ACCOUNT_ID="sa",
+                    SERVICE_ACCOUNT_SECRET_NAME="sa_secret_name",
+                    LOGIN="admin",
+                    PASSWORD_SECRET_NAME="secret_name"
+                );
+            )sql");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#('('('"auth_method" '"MDB_BASIC") '('"location" '"protocol://host:port/") '('"login" '"admin") '('"password_secret_name" '"secret_name") '('"service_account_id" '"sa") '('"service_account_secret_name" '"sa_secret_name") '('"source_type" '"PostgreSQL"))#");
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("createObject"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(CreateExternalDataSourceWithAws) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+                USE plato;
+                CREATE EXTERNAL DATA SOURCE MyDataSource WITH (
+                    SOURCE_TYPE="PostgreSQL",
+                    LOCATION="protocol://host:port/",
+                    AUTH_METHOD="AWS",
+                    AWS_ACCESS_KEY_ID_SECRET_NAME="secred_id_name",
+                    AWS_SECRET_ACCESS_KEY_SECRET_NAME="secret_key_name",
+                    AWS_REGION="ru-central-1"
+                );
+            )sql");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#('('('"auth_method" '"AWS") '('"aws_access_key_id_secret_name" '"secred_id_name") '('"aws_region" '"ru-central-1") '('"aws_secret_access_key_secret_name" '"secret_key_name") '('"location" '"protocol://host:port/") '('"source_type" '"PostgreSQL"))#");
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("createObject"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(CreateExternalDataSourceWithToken) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+                USE plato;
+                CREATE EXTERNAL DATA SOURCE MyDataSource WITH (
+                    SOURCE_TYPE="YT",
+                    LOCATION="protocol://host:port/",
+                    AUTH_METHOD="TOKEN",
+                    TOKEN_SECRET_NAME="token_name"
+                );
+            )sql");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#('('('"auth_method" '"TOKEN") '('"location" '"protocol://host:port/") '('"source_type" '"YT") '('"token_secret_name" '"token_name"))#");
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("createObject"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(CreateExternalDataSourceWithTablePrefix) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+                USE plato;
+                pragma TablePathPrefix='/aba';
+                CREATE EXTERNAL DATA SOURCE MyDataSource WITH (
+                    SOURCE_TYPE="ObjectStorage",
+                    LOCATION="my-bucket",
+                    AUTH_METHOD="NONE"
+                );
+            )sql");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_STRING_CONTAINS(line, "/aba/MyDataSource");
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("createObject"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(CreateExternalDataSourceIfNotExists) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+                USE plato;
+                CREATE EXTERNAL DATA SOURCE IF NOT EXISTS MyDataSource WITH (
+                    SOURCE_TYPE="ObjectStorage",
+                    LOCATION="my-bucket",
+                    AUTH_METHOD="NONE"
+                );
+            )sql");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#('('('"auth_method" '"NONE") '('"location" '"my-bucket") '('"source_type" '"ObjectStorage"))#");
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("createObjectIfNotExists"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(AlterExternalDataSource) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+                USE plato;
+                ALTER EXTERNAL DATA SOURCE MyDataSource
+                    SET (SOURCE_TYPE = "ObjectStorage", Login = "Admin"),
+                    SET Location "bucket",
+                    RESET (Auth_Method, Service_Account_Id, Service_Account_Secret_Name);
+            )sql");
+        UNIT_ASSERT_C(res.Root, res.Issues.ToString());
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#(('mode 'alterObject))#");
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#('('features '('('"location" '"bucket") '('"login" '"Admin") '('"source_type" '"ObjectStorage"))))#");
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#('('resetFeatures '('"auth_method" '"service_account_id" '"service_account_secret_name")))#");
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(CreateExternalDataSourceOrReplace) {
+        NYql::TAstParseResult res = SqlToYql(R"(
+                USE plato;
+                CREATE OR REPLACE EXTERNAL DATA SOURCE MyDataSource WITH (
+                    SOURCE_TYPE="ObjectStorage",
+                    LOCATION="my-bucket",
+                    AUTH_METHOD="NONE"
+                );
+            )");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#('('('"auth_method" '"NONE") '('"location" '"my-bucket") '('"source_type" '"ObjectStorage"))#");
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("createObjectOrReplace"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(CreateOrReplaceForUnsupportedTableTypesShouldFail) {
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE OR REPLACE TABLE t (a int32 not null, primary key(a, a));
+            )sql" , "<main>:3:23: Error: OR REPLACE feature is supported only for EXTERNAL DATA SOURCE and EXTERNAL TABLE\n");
+
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE OR REPLACE TABLE t (
+                    Key Uint64,
+                    Value1 String,
+                    PRIMARY KEY (Key)
+                )
+                WITH (
+                    STORE = COLUMN,
+                    AUTO_PARTITIONING_MIN_PARTITIONS_COUNT = 10
+                );
+            )sql" , "<main>:3:23: Error: OR REPLACE feature is supported only for EXTERNAL DATA SOURCE and EXTERNAL TABLE\n");
+    }
+
+    Y_UNIT_TEST(CreateExternalDataSourceWithBadArguments) {
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE EXTERNAL DATA SOURCE MyDataSource;
+            )sql" , "<main>:3:56: Error: mismatched input ';' expecting WITH\n");
+
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE EXTERNAL DATA SOURCE MyDataSource WITH (
+                    LOCATION="my-bucket",
+                    AUTH_METHOD="NONE"
+                );
+            )sql" , "<main>:5:33: Error: SOURCE_TYPE requires key\n");
+
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE EXTERNAL DATA SOURCE MyDataSource WITH (
+                    SOURCE_TYPE="ObjectStorage",
+                    LOCATION="my-bucket"
+                );
+            )sql" , "<main>:5:30: Error: AUTH_METHOD requires key\n");
+
+
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE EXTERNAL DATA SOURCE MyDataSource WITH (
+                    SOURCE_TYPE="ObjectStorage",
+                    LOCATION="my-bucket",
+                    AUTH_METHOD="NONE1"
+                );
+            )sql" , "<main>:6:33: Error: Unknown AUTH_METHOD = NONE1\n");
+
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE EXTERNAL DATA SOURCE MyDataSource WITH (
+                    SOURCE_TYPE="ObjectStorage",
+                    LOCATION="my-bucket",
+                    AUTH_METHOD="SERVICE_ACCOUNT"
+                );
+            )sql" , "<main>:6:33: Error: SERVICE_ACCOUNT_ID requires key\n");
+
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE EXTERNAL DATA SOURCE MyDataSource WITH (
+                    SOURCE_TYPE="ObjectStorage",
+                    LOCATION="my-bucket",
+                    AUTH_METHOD="SERVICE_ACCOUNT",
+                    SERVICE_ACCOUNT_ID="s1"
+                );
+            )sql" , "<main>:7:40: Error: SERVICE_ACCOUNT_SECRET_NAME requires key\n");
+
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE EXTERNAL DATA SOURCE MyDataSource WITH (
+                    SOURCE_TYPE="ObjectStorage",
+                    LOCATION="my-bucket",
+                    AUTH_METHOD="SERVICE_ACCOUNT",
+                    SERVICE_ACCOUNT_SECRET_NAME="s1"
+                );
+            )sql" , "<main>:7:49: Error: SERVICE_ACCOUNT_ID requires key\n");
+
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE EXTERNAL DATA SOURCE MyDataSource WITH (
+                    SOURCE_TYPE="PostgreSQL",
+                    LOCATION="protocol://host:port/",
+                    AUTH_METHOD="BASIC",
+                    LOGIN="admin"
+                );
+            )sql" , "<main>:7:27: Error: PASSWORD_SECRET_NAME requires key\n");
+
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE EXTERNAL DATA SOURCE MyDataSource WITH (
+                    SOURCE_TYPE="PostgreSQL",
+                    LOCATION="protocol://host:port/",
+                    AUTH_METHOD="BASIC",
+                    PASSWORD_SECRET_NAME="secret_name"
+                );
+            )sql" , "<main>:7:42: Error: LOGIN requires key\n");
+
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE EXTERNAL DATA SOURCE MyDataSource WITH (
+                    SOURCE_TYPE="PostgreSQL",
+                    LOCATION="protocol://host:port/",
+                    AUTH_METHOD="MDB_BASIC",
+                    SERVICE_ACCOUNT_SECRET_NAME="sa_secret_name",
+                    LOGIN="admin",
+                    PASSWORD_SECRET_NAME="secret_name"
+                );
+            )sql" , "<main>:9:42: Error: SERVICE_ACCOUNT_ID requires key\n");
+
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE EXTERNAL DATA SOURCE MyDataSource WITH (
+                    SOURCE_TYPE="PostgreSQL",
+                    LOCATION="protocol://host:port/",
+                    AUTH_METHOD="MDB_BASIC",
+                    SERVICE_ACCOUNT_ID="sa",
+                    LOGIN="admin",
+                    PASSWORD_SECRET_NAME="secret_name"
+                );
+            )sql" , "<main>:9:42: Error: SERVICE_ACCOUNT_SECRET_NAME requires key\n");
+
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE EXTERNAL DATA SOURCE MyDataSource WITH (
+                    SOURCE_TYPE="PostgreSQL",
+                    LOCATION="protocol://host:port/",
+                    AUTH_METHOD="MDB_BASIC",
+                    SERVICE_ACCOUNT_ID="sa",
+                    SERVICE_ACCOUNT_SECRET_NAME="sa_secret_name",
+                    PASSWORD_SECRET_NAME="secret_name"
+                );
+            )sql" , "<main>:9:42: Error: LOGIN requires key\n");
+
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE EXTERNAL DATA SOURCE MyDataSource WITH (
+                    SOURCE_TYPE="PostgreSQL",
+                    LOCATION="protocol://host:port/",
+                    AUTH_METHOD="MDB_BASIC",
+                    SERVICE_ACCOUNT_ID="sa",
+                    SERVICE_ACCOUNT_SECRET_NAME="sa_secret_name",
+                    LOGIN="admin"
+                );
+            )sql" , "<main>:9:27: Error: PASSWORD_SECRET_NAME requires key\n");
+
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE EXTERNAL DATA SOURCE MyDataSource WITH (
+                    SOURCE_TYPE="PostgreSQL",
+                    LOCATION="protocol://host:port/",
+                    AUTH_METHOD="AWS",
+                    AWS_SECRET_ACCESS_KEY_SECRET_NAME="secret_key_name",
+                    AWS_REGION="ru-central-1"
+                );
+            )sql" , "<main>:8:32: Error: AWS_ACCESS_KEY_ID_SECRET_NAME requires key\n");
+
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE EXTERNAL DATA SOURCE MyDataSource WITH (
+                    SOURCE_TYPE="PostgreSQL",
+                    LOCATION="protocol://host:port/",
+                    AUTH_METHOD="AWS",
+                    AWS_ACCESS_KEY_ID_SECRET_NAME="secred_id_name",
+                    AWS_REGION="ru-central-1"
+                );
+            )sql" , "<main>:8:32: Error: AWS_SECRET_ACCESS_KEY_SECRET_NAME requires key\n");
+
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE EXTERNAL DATA SOURCE MyDataSource WITH (
+                    SOURCE_TYPE="PostgreSQL",
+                    LOCATION="protocol://host:port/",
+                    AUTH_METHOD="AWS",
+                    AWS_SECRET_ACCESS_KEY_SECRET_NAME="secret_key_name",
+                    AWS_ACCESS_KEY_ID_SECRET_NAME="secred_id_name"
+                );
+            )sql" , "<main>:8:51: Error: AWS_REGION requires key\n");
+    }
+
+    Y_UNIT_TEST(DropExternalDataSourceWithTablePrefix) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+                USE plato;
+                DROP EXTERNAL DATA SOURCE MyDataSource;
+            )sql");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_EQUAL(TString::npos, line.find("'features"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("dropObject"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(DropExternalDataSource) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+                USE plato;
+                pragma TablePathPrefix='/aba';
+                DROP EXTERNAL DATA SOURCE MyDataSource;
+            )sql");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_STRING_CONTAINS(line, "/aba/MyDataSource");
+                UNIT_ASSERT_VALUES_EQUAL(TString::npos, line.find("'features"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("dropObject"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(DropExternalDataSourceIfExists) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+                USE plato;
+                DROP EXTERNAL DATA SOURCE IF EXISTS MyDataSource;
+            )sql");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_STRING_CONTAINS(line, "MyDataSource");
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("dropObjectIfExists"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+}
+
+Y_UNIT_TEST_SUITE(ExternalTable) {
+    Y_UNIT_TEST(CreateExternalTable) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+            USE plato;
+            CREATE EXTERNAL TABLE mytable (
+                a int
+            ) WITH (
+                DATA_SOURCE="/Root/mydatasource",
+                LOCATION="/folder1/*"
+            );
+        )sql");
+        UNIT_ASSERT_C(res.Root, res.Issues.ToOneLineString());
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#('('('data_source_path (String '"/Root/mydatasource")) '('location (String '"/folder1/*")))) '('tableType 'externalTable)))))#");
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("tablescheme"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(CreateExternalTableWithTablePrefix) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+            USE plato;
+            pragma TablePathPrefix='/aba';
+            CREATE EXTERNAL TABLE mytable (
+                a int
+            ) WITH (
+                DATA_SOURCE="mydatasource",
+                LOCATION="/folder1/*"
+            );
+        )sql");
+        UNIT_ASSERT_C(res.Root, res.Issues.ToOneLineString());
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_STRING_CONTAINS(line, "/aba/mydatasource");
+                UNIT_ASSERT_STRING_CONTAINS(line, "/aba/mytable");
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("tablescheme"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(CreateExternalTableObjectStorage) {
+        auto res = SqlToYql(R"sql(
+            USE plato;
+            CREATE EXTERNAL TABLE mytable (
+                a int,
+                year Int
+            ) WITH (
+                DATA_SOURCE="/Root/mydatasource",
+                LOCATION="/folder1/*",
+                FORMAT="json_as_string",
+                `projection.enabled`="true",
+                `projection.year.type`="integer",
+                `projection.year.min`="2010",
+                `projection.year.max`="2022",
+                `projection.year.interval`="1",
+                `projection.month.type`="integer",
+                `projection.month.min`="1",
+                `projection.month.max`="12",
+                `projection.month.interval`="1",
+                `projection.month.digits`="2",
+                `storage.location.template`="${year}/${month}",
+                PARTITONED_BY = "[year, month]"
+            );
+        )sql");
+        UNIT_ASSERT_C(res.IsOk(), res.Issues.ToString());
+    }
+
+    Y_UNIT_TEST(CreateExternalTableIfNotExists) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+            USE plato;
+            CREATE EXTERNAL TABLE IF NOT EXISTS mytable (
+                a int
+            ) WITH (
+                DATA_SOURCE="/Root/mydatasource",
+                LOCATION="/folder1/*"
+            );
+        )sql");
+        UNIT_ASSERT_C(res.Root, res.Issues.ToOneLineString());
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#('('('data_source_path (String '"/Root/mydatasource")) '('location (String '"/folder1/*")))) '('tableType 'externalTable)))))#");
+                UNIT_ASSERT_STRING_CONTAINS(line, "create_if_not_exists");
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(CreateExternalTableOrReplace) {
+        NYql::TAstParseResult res = SqlToYql(R"(
+            USE plato;
+            CREATE OR REPLACE EXTERNAL TABLE mytable (
+                a int
+            ) WITH (
+                DATA_SOURCE="/Root/mydatasource",
+                LOCATION="/folder1/*"
+            );
+        )");
+        UNIT_ASSERT_C(res.Root, res.Issues.ToOneLineString());
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#('('('data_source_path (String '"/Root/mydatasource")) '('location (String '"/folder1/*")))) '('tableType 'externalTable)))))#");
+                UNIT_ASSERT_STRING_CONTAINS(line, "create_or_replace");
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(AlterExternalTableAddColumn) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+            USE plato;
+            ALTER EXTERNAL TABLE mytable
+                ADD COLUMN my_column int32,
+                RESET (LOCATION);
+        )sql");
+        UNIT_ASSERT_C(res.Root, res.Issues.ToOneLineString());
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#('actions '('('addColumns '('('"my_column" (AsOptionalType (DataType 'Int32))#");
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#(('setTableSettings '('('location)))#");
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#(('tableType 'externalTable))#");
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#(('mode 'alter))#");
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(AlterExternalTableDropColumn) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+            USE plato;
+            ALTER EXTERNAL TABLE mytable
+                DROP COLUMN my_column,
+                SET (Location = "abc", Other_Prop = "42"),
+                SET x 'y';
+        )sql");
+        UNIT_ASSERT_C(res.Root, res.Issues.ToOneLineString());
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#('actions '('('dropColumns '('"my_column")#");
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#(('setTableSettings '('('location (String '"abc")) '('Other_Prop (String '"42")) '('x (String '"y")))))#");
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#(('tableType 'externalTable))#");
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#(('mode 'alter))#");
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(CreateExternalTableWithBadArguments) {
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE EXTERNAL TABLE mytable;
+            )sql" , "<main>:3:45: Error: mismatched input ';' expecting '('\n");
+
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE EXTERNAL TABLE mytable (
+                    a int
+                );
+            )sql" , "<main>:4:23: Error: DATA_SOURCE requires key\n");
+
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE EXTERNAL TABLE mytable (
+                    a int
+                ) WITH (
+                    DATA_SOURCE="/Root/mydatasource"
+                );
+            )sql" , "<main>:6:33: Error: LOCATION requires key\n");
+
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE EXTERNAL TABLE mytable (
+                    a int
+                ) WITH (
+                    LOCATION="/folder1/*"
+                );
+            )sql" , "<main>:6:30: Error: DATA_SOURCE requires key\n");
+
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE EXTERNAL TABLE mytable (
+                    a int,
+                    PRIMARY KEY(a)
+                ) WITH (
+                    DATA_SOURCE="/Root/mydatasource",
+                    LOCATION="/folder1/*"
+                );
+            )sql" , "<main>:8:30: Error: PRIMARY KEY is not supported for external table\n");
+    }
+
+    Y_UNIT_TEST(DropExternalTable) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+                USE plato;
+                DROP EXTERNAL TABLE MyExternalTable;
+            )sql");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_EQUAL(TString::npos, line.find("tablescheme"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(DropExternalTableWithTablePrefix) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+                USE plato;
+                pragma TablePathPrefix='/aba';
+                DROP EXTERNAL TABLE MyExternalTable;
+            )sql");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_STRING_CONTAINS(line, "/aba/MyExternalTable");
+                UNIT_ASSERT_VALUES_EQUAL(TString::npos, line.find("'tablescheme"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(DropExternalTableIfExists) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+                USE plato;
+                DROP EXTERNAL TABLE IF EXISTS MyExternalTable;
+            )sql");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_EQUAL(TString::npos, line.find("tablescheme"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("drop_if_exists"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+}
+
+Y_UNIT_TEST_SUITE(TopicsDDL) {
+    void TestQuery(const TString& query, bool expectOk = true) {
+        TStringBuilder finalQuery;
+
+        finalQuery << "use plato;" << Endl << query;
+        auto res = SqlToYql(finalQuery, 10, "kikimr");
+        if (expectOk) {
+            UNIT_ASSERT_C(res.IsOk(), res.Issues.ToString());
+        } else {
+            UNIT_ASSERT(!res.IsOk());
+        }
+    }
+
+    Y_UNIT_TEST(CreateTopicSimple) {
+        TestQuery(R"(
+            CREATE TOPIC topic1;
+        )");
+        TestQuery(R"(
+            CREATE TOPIC `cluster1.topic1`;
+        )");
+        TestQuery(R"(
+            CREATE TOPIC topic1 WITH (metering_mode = "str_value", partition_count_limit = 123, retention_period = Interval('PT1H'));
+        )");
+    }
+
+    Y_UNIT_TEST(CreateTopicConsumer) {
+        TestQuery(R"(
+            CREATE TOPIC topic1 (CONSUMER cons1);
+        )");
+        TestQuery(R"(
+            CREATE TOPIC topic1 (CONSUMER cons1, CONSUMER cons2 WITH (important = false));
+        )");
+        TestQuery(R"(
+            CREATE TOPIC topic1 (CONSUMER cons1, CONSUMER cons2 WITH (important = false)) WITH (supported_codecs = "1,2,3");
+        )");
+    }
+
+    Y_UNIT_TEST(AlterTopicSimple) {
+        TestQuery(R"(
+            ALTER TOPIC topic1 SET (retention_period = Interval('PT1H'));
+        )");
+        TestQuery(R"(
+            ALTER TOPIC topic1 SET (retention_storage_mb = 3, partition_count_limit = 50);
+        )");
+        TestQuery(R"(
+            ALTER TOPIC topic1 RESET (supported_codecs, retention_period);
+        )");
+        TestQuery(R"(
+            ALTER TOPIC topic1 RESET (partition_write_speed_bytes_per_second),
+                 SET (partition_write_burst_bytes = 11111, min_active_partitions = 1);
+        )");
+    }
+    Y_UNIT_TEST(AlterTopicConsumer) {
+        TestQuery(R"(
+            ALTER TOPIC topic1 ADD CONSUMER consumer1,
+                ADD CONSUMER consumer2 WITH (important = false, supported_codecs = "RAW"),
+                ALTER CONSUMER consumer3 SET (important = false, read_from = 1),
+                ALTER CONSUMER consumer3 RESET (supported_codecs),
+                DROP CONSUMER consumer4,
+                SET (partition_count_limit = 11, retention_period = Interval('PT1H')),
+                RESET(metering_mode)
+        )");
+    }
+    Y_UNIT_TEST(DropTopic) {
+        TestQuery(R"(
+            DROP TOPIC topic1;
+        )");
+    }
+
+    Y_UNIT_TEST(TopicBadRequests) {
+        TestQuery(R"(
+            CREATE TOPIC topic1();
+        )", false);
+        TestQuery(R"(
+            CREATE TOPIC topic1 SET setting1 = value1;
+        )", false);
+        TestQuery(R"(
+            ALTER TOPIC topic1 SET setting1 value1;
+        )", false);
+        TestQuery(R"(
+            ALTER TOPIC topic1 RESET setting1;
+        )", false);
+
+        TestQuery(R"(
+            ALTER TOPIC topic1 DROP CONSUMER consumer4 WITH (k1 = v1);
+        )", false);
+
+        TestQuery(R"(
+            CREATE TOPIC topic1 WITH (retention_period = 123);
+        )", false);
+        TestQuery(R"(
+            CREATE TOPIC topic1 (CONSUMER cons1, CONSUMER cons1 WITH (important = false));
+        )", false);
+        TestQuery(R"(
+            CREATE TOPIC topic1 (CONSUMER cons1 WITH (bad_option = false));
+        )", false);
+        TestQuery(R"(
+            ALTER TOPIC topic1 ADD CONSUMER cons1, ALTER CONSUMER cons1 RESET (important);
+        )", false);
+        TestQuery(R"(
+            ALTER TOPIC topic1 ADD CONSUMER consumer1,
+                ALTER CONSUMER consumer3 SET (supported_codecs = "RAW", read_from = 1),
+                ALTER CONSUMER consumer3 RESET (supported_codecs);
+        )", false);
+        TestQuery(R"(
+            ALTER TOPIC topic1 ADD CONSUMER consumer1,
+                ALTER CONSUMER consumer3 SET (supported_codecs = "RAW", read_from = 1),
+                ALTER CONSUMER consumer3 SET (read_from = 2);
+        )", false);
+    }
+
+    Y_UNIT_TEST(TopicWithPrefix) {
+        NYql::TAstParseResult res = SqlToYql(R"(
+            USE plato;
+            PRAGMA TablePathPrefix = '/database/path/to/tables';
+            ALTER TOPIC `my_table/my_feed` ADD CONSUMER `my_consumer`;
+        )");
+        UNIT_ASSERT(res.Root);
+
+        TWordCountHive elementStat = {{TString("/database/path/to/tables/my_table/my_feed"), 0}, {"topic", 0}};
+        VerifyProgram(res, elementStat);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["topic"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["/database/path/to/tables/my_table/my_feed"]);
+    }
+}
+
+Y_UNIT_TEST_SUITE(BlockEnginePragma) {
+    Y_UNIT_TEST(Basic) {
+        const TVector<TString> values = {"auto", "force", "disable"};
+        for (const auto& value : values) {
+            const auto query = TStringBuilder() << "pragma Blockengine='" << value << "'; select 1;";
+            NYql::TAstParseResult res = SqlToYql(query);
+            UNIT_ASSERT(res.Root);
+
+            TVerifyLineFunc verifyLine = [&](const TString& word, const TString& line) {
+                Y_UNUSED(word);
+                UNIT_ASSERT_STRING_CONTAINS(line, TStringBuilder() << R"(Configure! world (DataSource '"config") '"BlockEngine" '")" << value << "\"");
+            };
+
+            TWordCountHive elementStat({"BlockEngine"});
+            VerifyProgram(res, elementStat, verifyLine);
+            UNIT_ASSERT(elementStat["BlockEngine"] == ((value == "disable") ? 0 : 1));
+        }
+    }
+
+    Y_UNIT_TEST(UnknownSetting) {
+        ExpectFailWithError("use plato; pragma BlockEngine='foo';",
+            "<main>:1:31: Error: Expected `disable|auto|force' argument for: BlockEngine\n");
+    }
+}
+
+Y_UNIT_TEST_SUITE(TViewSyntaxTest) {
+    Y_UNIT_TEST(CreateViewSimple) {
+        NYql::TAstParseResult res = SqlToYql(R"(
+                USE plato;
+                CREATE VIEW TheView WITH (security_invoker = TRUE) AS SELECT 1;
+            )"
+        );
+        UNIT_ASSERT_C(res.Root, res.Issues.ToString());
+    }
+
+    Y_UNIT_TEST(CreateViewNoSecurityInvoker) {
+        NYql::TAstParseResult res = SqlToYql(R"(
+                USE plato;
+                CREATE VIEW TheView AS SELECT 1;
+            )"
+        );
+        UNIT_ASSERT_STRING_CONTAINS(res.Issues.ToString(), "mismatched input 'AS' expecting WITH");
+    }
+
+    Y_UNIT_TEST(CreateViewSecurityInvokerTurnedOff) {
+        NYql::TAstParseResult res = SqlToYql(R"(
+                USE plato;
+                CREATE VIEW TheView WITH (security_invoker = FALSE) AS SELECT 1;
+            )"
+        );
+        UNIT_ASSERT_STRING_CONTAINS(res.Issues.ToString(), "SECURITY_INVOKER option must be explicitly enabled");
+    }
+
+    Y_UNIT_TEST(CreateViewFromTable) {
+        constexpr const char* path = "/PathPrefix/TheView";
+        constexpr const char* query = R"(
+            SELECT * FROM SomeTable
+        )";
+
+        NYql::TAstParseResult res = SqlToYql(std::format(R"(
+                    USE plato;
+                    CREATE VIEW `{}` WITH (security_invoker = TRUE) AS {};
+                )",
+                path,
+                query
+            )
+        );
+        UNIT_ASSERT_C(res.Root, res.Issues.ToString());
+
+        TVerifyLineFunc verifyLine = [&](const TString& word, const TString& line) {
+            if (word == "Write!") {
+                UNIT_ASSERT_STRING_CONTAINS(line, path);
+                UNIT_ASSERT_STRING_CONTAINS(line, "createObject");
+            }
+        };
+        TWordCountHive elementStat = { {"Write!"} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(elementStat["Write!"], 1);
+    }
+
+    Y_UNIT_TEST(CheckReconstructedQuery) {
+        constexpr const char* path = "/PathPrefix/TheView";
+        constexpr const char* query = R"(
+            SELECT * FROM FirstTable JOIN SecondTable ON FirstTable.key == SecondTable.key
+        )";
+
+        NYql::TAstParseResult res = SqlToYql(std::format(R"(
+                    USE plato;
+                    CREATE VIEW `{}` WITH (security_invoker = TRUE) AS {};
+                )",
+                path,
+                query
+            )
+        );
+        UNIT_ASSERT_C(res.Root, res.Issues.ToString());
+
+        TString reconstructedQuery = ToString(Tokenize(query));
+        TVerifyLineFunc verifyLine = [&](const TString& word, const TString& line) {
+            if (word == "query_text") {
+                UNIT_ASSERT_STRING_CONTAINS(line, reconstructedQuery);
+            }
+        };
+        TWordCountHive elementStat = { {"Write!"} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(elementStat["Write!"], 1);
+    }
+
+    Y_UNIT_TEST(DropView) {
+        constexpr const char* path = "/PathPrefix/TheView";
+        NYql::TAstParseResult res = SqlToYql(std::format(R"(
+                    USE plato;
+                    DROP VIEW `{}`;
+                )",
+                path
+            )
+        );
+        UNIT_ASSERT_C(res.Root, res.Issues.ToString());
+
+        TVerifyLineFunc verifyLine = [&](const TString& word, const TString& line) {
+            if (word == "Write!") {
+                UNIT_ASSERT_STRING_CONTAINS(line, path);
+                UNIT_ASSERT_STRING_CONTAINS(line, "dropObject");
+            }
+        };
+        TWordCountHive elementStat = { {"Write!"} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(elementStat["Write!"], 1);
+    }
+
+    Y_UNIT_TEST(CreateViewWithTablePrefix) {
+        NYql::TAstParseResult res = SqlToYql(R"(
+                USE plato;
+                PRAGMA TablePathPrefix='/PathPrefix';
+                CREATE VIEW TheView WITH (security_invoker = TRUE) AS SELECT 1;
+            )"
+        );
+        UNIT_ASSERT_C(res.Root, res.Issues.ToString());
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write!") {
+                UNIT_ASSERT_STRING_CONTAINS(line, "/PathPrefix/TheView");
+                UNIT_ASSERT_STRING_CONTAINS(line, "createObject");
+            }
+        };
+
+        TWordCountHive elementStat = { {"Write!"} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(elementStat["Write!"], 1);
+    }
+
+    Y_UNIT_TEST(DropViewWithTablePrefix) {
+        NYql::TAstParseResult res = SqlToYql(R"(
+                USE plato;
+                PRAGMA TablePathPrefix='/PathPrefix';
+                DROP VIEW TheView;
+            )"
+        );
+        UNIT_ASSERT_C(res.Root, res.Issues.ToString());
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_STRING_CONTAINS(line, "/PathPrefix/TheView");
+                UNIT_ASSERT_STRING_CONTAINS(line, "dropObject");
+            }
+        };
+
+        TWordCountHive elementStat = { {"Write!"} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(elementStat["Write!"], 1);
+    }
+    
+    Y_UNIT_TEST(YtAlternativeSchemaSyntax) {
+        NYql::TAstParseResult res = SqlToYql(R"(
+            SELECT * FROM plato.Input WITH schema(y Int32, x String not null);
+        )");
+        UNIT_ASSERT_C(res.Root, res.Issues.ToString());
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "userschema") {
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos,
+                    line.find(R"__('('('"userschema" (StructType '('"y" (AsOptionalType (DataType 'Int32))) '('"x" (DataType 'String))))))__"));
+            }
+        };
+
+        TWordCountHive elementStat = {{TString("userschema"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["userschema"]);
+    }
+
+    Y_UNIT_TEST(UseViewAndFullColumnId) {
+        NYql::TAstParseResult res = SqlToYql("USE plato; SELECT Input.x FROM Input VIEW uitzicht;");
+        UNIT_ASSERT(res.Root);
+
+        TWordCountHive elementStat = {{TString("SqlAccess"), 0}, {"SqlProjectItem", 0}, {"Read!", 0}};
+        VerifyProgram(res, elementStat);
+        UNIT_ASSERT_VALUES_EQUAL(0, elementStat["SqlAccess"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["SqlProjectItem"]);
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Read!"]);
+    }
+}
+
+Y_UNIT_TEST_SUITE(CompactNamedExprs) {
+    Y_UNIT_TEST(SourceCallablesInWrongContext) {
+        TString query = R"(
+            pragma CompactNamedExprs;
+            $foo = %s();
+            select $foo from plato.Input;
+        )";
+
+        THashMap<TString, TString> errs = {
+            {"TableRow", "<main>:3:20: Error: TableRow requires data source\n"},
+            {"JoinTableRow", "<main>:3:20: Error: JoinTableRow requires data source\n"},
+            {"TableRecordIndex", "<main>:3:20: Error: Unable to use function: TableRecord without source\n"},
+            {"TablePath", "<main>:3:20: Error: Unable to use function: TablePath without source\n"},
+            {"SystemMetadata", "<main>:3:20: Error: Unable to use function: SystemMetadata without source\n"},
+        };
+
+        for (TString callable : { "TableRow", "JoinTableRow", "TableRecordIndex", "TablePath", "SystemMetadata"}) {
+            auto req = Sprintf(query.c_str(), callable.c_str());
+            ExpectFailWithError(req, errs[callable]);
+        }
+    }
+
+    Y_UNIT_TEST(ValidateUnusedExprs) {
+        TString query = R"(
+            pragma warning("disable", "4527");
+            pragma CompactNamedExprs;
+            pragma ValidateUnusedExprs;
+
+            $foo = count(1);
+            select 1;
+        )";
+        ExpectFailWithError(query, "<main>:6:20: Error: Aggregation is not allowed in this context\n");
+        query = R"(
+            pragma warning("disable", "4527");
+            pragma CompactNamedExprs;
+            pragma ValidateUnusedExprs;
+
+            define subquery $x() as 
+                select count(1, 2);
+            end define;
+            select 1;
+        )";
+        ExpectFailWithError(query, "<main>:7:24: Error: Aggregation function Count requires exactly 1 argument(s), given: 2\n");
+    }
+
+    Y_UNIT_TEST(DisableValidateUnusedExprs) {
+        TString query = R"(
+            pragma warning("disable", "4527");
+            pragma CompactNamedExprs;
+            pragma DisableValidateUnusedExprs;
+
+            $foo = count(1);
+            select 1;
+        )";
+        SqlToYql(query).IsOk();
+        query = R"(
+            pragma warning("disable", "4527");
+            pragma CompactNamedExprs;
+            pragma DisableValidateUnusedExprs;
+
+            define subquery $x() as 
+                select count(1, 2);
+            end define;
+            select 1;
+        )";
+        SqlToYql(query).IsOk();
+    }
+}
+
+Y_UNIT_TEST_SUITE(ResourcePool) {
+    Y_UNIT_TEST(CreateResourcePool) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+                USE plato;
+                CREATE RESOURCE POOL MyResourcePool WITH (
+                    CONCURRENT_QUERY_LIMIT=20,
+                    QUERY_CANCEL_AFTER_SECONDS=86400,
+                    QUEUE_TYPE="FIFO"
+                );
+            )sql");
+        UNIT_ASSERT_C(res.Root, res.Issues.ToString());
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#('('('"concurrent_query_limit" (Int32 '"20")) '('"query_cancel_after_seconds" (Int32 '"86400")) '('"queue_type" '"FIFO"))#");
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("createObject"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(CreateResourcePoolWithBadArguments) {
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE RESOURCE POOL MyResourcePool;
+            )sql" , "<main>:3:51: Error: mismatched input ';' expecting WITH\n");
+
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE RESOURCE POOL MyResourcePool WITH (
+                    DUPLICATE_SETTING="first_value",
+                    DUPLICATE_SETTING="second_value"
+                );
+            )sql" , "<main>:5:21: Error: DUPLICATE_SETTING duplicate keys\n");
+    }
+
+    Y_UNIT_TEST(AlterResourcePool) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+                USE plato;
+                ALTER RESOURCE POOL MyResourcePool
+                    SET (CONCURRENT_QUERY_LIMIT = 30, Weight = 5, QUEUE_TYPE = "UNORDERED"),
+                    RESET (Query_Cancel_After_Seconds, Query_Count_Limit);
+            )sql");
+        UNIT_ASSERT_C(res.Root, res.Issues.ToString());
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#(('mode 'alterObject))#");
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#('('features '('('"concurrent_query_limit" (Int32 '"30")) '('"queue_type" '"UNORDERED") '('"weight" (Int32 '"5")))))#");
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#('('resetFeatures '('"query_cancel_after_seconds" '"query_count_limit")))#");
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(DropResourcePool) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+                USE plato;
+                DROP RESOURCE POOL MyResourcePool;
+            )sql");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_EQUAL(TString::npos, line.find("'features"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("dropObject"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+}
+
+Y_UNIT_TEST_SUITE(BackupCollection) {
+    Y_UNIT_TEST(CreateBackupCollection) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+                USE plato;
+                CREATE BACKUP COLLECTION TestCollection WITH (
+                    STORAGE="local",
+                    TAG="test" -- for testing purposes, not a real thing
+                );
+            )sql");
+        UNIT_ASSERT_C(res.Root, res.Issues.ToString());
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#('('('"storage" '"local") '('"tag" '"test"))#");
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("createObject"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(CreateBackupCollectionWithBadArguments) {
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE BACKUP COLLECTION TestCollection;
+            )sql" , "<main>:3:55: Error: mismatched input ';' expecting WITH\n");
+
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE BACKUP COLLECTION TestCollection WITH (
+                    DUPLICATE_SETTING="first_value",
+                    DUPLICATE_SETTING="second_value"
+                );
+            )sql" , "<main>:5:21: Error: DUPLICATE_SETTING duplicate keys\n");
+
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE BACKUP COLLECTION TestCollection WITH (
+                    INT_SETTING=1
+                );
+            )sql" , "<main>:4:21: Error: INT_SETTING value should be a string literal\n");
+    }
+
+    Y_UNIT_TEST(AlterBackupCollection) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+                USE plato;
+                ALTER BACKUP COLLECTION TestCollection
+                    SET (STORAGE="remote"), -- also just for test
+                    SET (TAG1 = "123"),
+                    RESET (TAG2, TAG3);
+            )sql");
+        UNIT_ASSERT_C(res.Root, res.Issues.ToString());
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#(('mode 'alterObject))#");
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#('('features '('('"storage" '"remote") '('"tag1" '"123"))))#");
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#('('resetFeatures '('"tag2" '"tag3")))#");
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(DropBackupCollection) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+                USE plato;
+                DROP BACKUP COLLECTION TestCollection;
+            )sql");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_EQUAL(TString::npos, line.find("'features"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("dropObject"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+}
+
+Y_UNIT_TEST_SUITE(ResourcePoolClassifier) {
+    Y_UNIT_TEST(CreateResourcePoolClassifier) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+                USE plato;
+                CREATE RESOURCE POOL CLASSIFIER MyResourcePoolClassifier WITH (
+                    RANK=20,
+                    RESOURCE_POOL='wgUserQueries',
+                    MEMBERNAME='yandex_query@abc'
+                );
+            )sql");
+        UNIT_ASSERT_C(res.Root, res.Issues.ToString());
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#('('('"membername" '"yandex_query@abc") '('"rank" (Int32 '"20")) '('"resource_pool" '"wgUserQueries"))#");
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("createObject"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(CreateResourcePoolClassifierWithBadArguments) {
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE RESOURCE POOL CLASSIFIER MyResourcePoolClassifier;
+            )sql" , "<main>:3:72: Error: mismatched input ';' expecting WITH\n");
+
+        ExpectFailWithError(R"sql(
+                USE plato;
+                CREATE RESOURCE POOL CLASSIFIER MyResourcePoolClassifier WITH (
+                    DUPLICATE_SETTING="first_value",
+                    DUPLICATE_SETTING="second_value"
+                );
+            )sql" , "<main>:5:21: Error: DUPLICATE_SETTING duplicate keys\n");
+    }
+
+    Y_UNIT_TEST(AlterResourcePoolClassifier) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+                USE plato;
+                ALTER RESOURCE POOL CLASSIFIER MyResourcePoolClassifier
+                    SET (RANK = 30, Weight = 5, MEMBERNAME = "test@user"),
+                    RESET (Resource_Pool);
+            )sql");
+        UNIT_ASSERT_C(res.Root, res.Issues.ToString());
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#(('mode 'alterObject))#");
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#('('features '('('"membername" '"test@user") '('"rank" (Int32 '"30")) '('"weight" (Int32 '"5")))))#");
+                UNIT_ASSERT_STRING_CONTAINS(line, R"#('('resetFeatures '('"resource_pool")))#");
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0} };
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+
+    Y_UNIT_TEST(DropResourcePoolClassifier) {
+        NYql::TAstParseResult res = SqlToYql(R"sql(
+                USE plato;
+                DROP RESOURCE POOL CLASSIFIER MyResourcePoolClassifier;
+            )sql");
+        UNIT_ASSERT(res.Root);
+
+        TVerifyLineFunc verifyLine = [](const TString& word, const TString& line) {
+            if (word == "Write") {
+                UNIT_ASSERT_VALUES_EQUAL(TString::npos, line.find("'features"));
+                UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("dropObject"));
+            }
+        };
+
+        TWordCountHive elementStat = { {TString("Write"), 0}};
+        VerifyProgram(res, elementStat, verifyLine);
+
+        UNIT_ASSERT_VALUES_EQUAL(1, elementStat["Write"]);
+    }
+}
diff --git a/ydb/library/yql/sql/v1/sql_ut_antlr4.h b/ydb/library/yql/sql/v1/sql_ut_antlr4.h
new file mode 100644
index 000000000000..640859a98ea7
--- /dev/null
+++ b/ydb/library/yql/sql/v1/sql_ut_antlr4.h
@@ -0,0 +1,226 @@
+
+#include <ydb/library/yql/providers/common/provider/yql_provider_names.h>
+#include <ydb/library/yql/sql/sql.h>
+#include <util/generic/map.h>
+
+#include <library/cpp/testing/unittest/registar.h>
+
+#include <util/string/split.h>
+#include <deque>
+#include <unordered_set>
+using namespace NSQLTranslation;
+
+enum class EDebugOutput {
+    None,
+    ToCerr,
+};
+
+const ui32 PRETTY_FLAGS = NYql::TAstPrintFlags::PerLine | NYql::TAstPrintFlags::ShortQuote |
+                          NYql::TAstPrintFlags::AdaptArbitraryContent;
+
+inline TString Err2Str(NYql::TAstParseResult& res, EDebugOutput debug = EDebugOutput::None) {
+    TStringStream s;
+    res.Issues.PrintTo(s);
+
+    if (debug == EDebugOutput::ToCerr) {
+        Cerr << s.Str() << Endl;
+    }
+    return s.Str();
+}
+
+inline NYql::TAstParseResult SqlToYqlWithMode(const TString& query, NSQLTranslation::ESqlMode mode = NSQLTranslation::ESqlMode::QUERY, size_t maxErrors = 10, const TString& provider = {},
+    EDebugOutput debug = EDebugOutput::None, bool ansiLexer = false, NSQLTranslation::TTranslationSettings settings = {})
+{
+    google::protobuf::Arena arena;
+    const auto service = provider ? provider : TString(NYql::YtProviderName);
+    const TString cluster = "plato";
+    settings.ClusterMapping[cluster] = service;
+    settings.ClusterMapping["hahn"] = NYql::YtProviderName;
+    settings.ClusterMapping["mon"] = NYql::SolomonProviderName;
+    settings.MaxErrors = maxErrors;
+    settings.Mode = mode;
+    settings.Arena = &arena;
+    settings.AnsiLexer = ansiLexer;
+    settings.Antlr4Parser = true;
+    settings.SyntaxVersion = 1;
+    auto res = SqlToYql(query, settings);
+    if (debug == EDebugOutput::ToCerr) {
+        Err2Str(res, debug);
+    }
+    return res;
+}
+
+inline NYql::TAstParseResult SqlToYql(const TString& query, size_t maxErrors = 10, const TString& provider = {}, EDebugOutput debug = EDebugOutput::None) {
+    return SqlToYqlWithMode(query, NSQLTranslation::ESqlMode::QUERY, maxErrors, provider, debug);
+}
+
+inline NYql::TAstParseResult SqlToYqlWithSettings(const TString& query, const NSQLTranslation::TTranslationSettings& settings) {
+    return SqlToYqlWithMode(query, NSQLTranslation::ESqlMode::QUERY, 10, {}, EDebugOutput::None, false, settings);
+}
+
+inline void ExpectFailWithError(const TString& query, const TString& error) {
+    NYql::TAstParseResult res = SqlToYql(query);
+
+    UNIT_ASSERT(!res.Root);
+    UNIT_ASSERT_NO_DIFF(Err2Str(res), error);
+}
+
+inline NYql::TAstParseResult SqlToYqlWithAnsiLexer(const TString& query, size_t maxErrors = 10, const TString& provider = {}, EDebugOutput debug = EDebugOutput::None) {
+    bool ansiLexer = true;
+    return SqlToYqlWithMode(query, NSQLTranslation::ESqlMode::QUERY, maxErrors, provider, debug, ansiLexer);
+}
+
+inline void ExpectFailWithErrorForAnsiLexer(const TString& query, const TString& error) {
+    NYql::TAstParseResult res = SqlToYqlWithAnsiLexer(query);
+
+    UNIT_ASSERT(!res.Root);
+    UNIT_ASSERT_NO_DIFF(Err2Str(res), error);
+}
+
+inline TString GetPrettyPrint(const NYql::TAstParseResult& res) {
+    TStringStream yqlProgram;
+    res.Root->PrettyPrintTo(yqlProgram, NYql::TAstPrintFlags::PerLine | NYql::TAstPrintFlags::ShortQuote);
+    return yqlProgram.Str();
+}
+
+inline TString Quote(const char* str) {
+    return TStringBuilder() << "'\"" << str << "\"";
+}
+
+class TWordCountHive: public TMap<TString, unsigned> {
+public:
+    TWordCountHive(std::initializer_list<TString> strings) {
+        for (auto& str: strings) {
+            emplace(str, 0);
+        }
+    }
+
+    TWordCountHive(std::initializer_list<std::pair<const TString, unsigned>> list)
+        : TMap(list)
+    {
+    }
+};
+
+typedef std::function<void (const TString& word, const TString& line)> TVerifyLineFunc;
+
+inline TString VerifyProgram(const NYql::TAstParseResult& res, TWordCountHive& wordCounter, TVerifyLineFunc verifyLine = TVerifyLineFunc()) {
+    const auto programm = GetPrettyPrint(res);
+    TVector<TString> yqlProgram;
+    Split(programm, "\n", yqlProgram);
+    for (const auto& line: yqlProgram) {
+        for (auto& counterIter: wordCounter) {
+            const auto& word = counterIter.first;
+            auto pos = line.find(word);
+            while (pos != TString::npos) {
+                ++counterIter.second;
+                if (verifyLine) {
+                    verifyLine(word, line);
+                }
+                pos = line.find(word, pos + word.length());
+            }
+        }
+    }
+    return programm;
+}
+
+inline void VerifySqlInHints(const TString& query, const THashSet<TString>& expectedHints, TMaybe<bool> ansi) {
+    TString pragma;
+    if (ansi.Defined()) {
+        pragma = *ansi ? "PRAGMA AnsiInForEmptyOrNullableItemsCollections;" :
+                         "PRAGMA DisableAnsiInForEmptyOrNullableItemsCollections;";
+    }
+
+    NYql::TAstParseResult res = SqlToYql(pragma + query);
+    UNIT_ASSERT(res.Root);
+
+    TVerifyLineFunc verifyLine = [&](const TString& word, const TString& line) {
+        Y_UNUSED(word);
+        if (!ansi.Defined()) {
+            UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("'('warnNoAnsi)"));
+        } else if (*ansi) {
+            UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find("'('ansi)"));
+        }
+        for (auto& hint : expectedHints)  {
+            UNIT_ASSERT_VALUES_UNEQUAL(TString::npos, line.find(hint));
+        }
+    };
+    TWordCountHive elementStat = {{TString("SqlIn"), 0}};
+    VerifyProgram(res, elementStat, verifyLine);
+}
+
+inline void VerifySqlInHints(const TString& query, const THashSet<TString>& expectedHints) {
+    VerifySqlInHints(query, expectedHints, false);
+    VerifySqlInHints(query, expectedHints, true);
+}
+
+inline NSQLTranslation::TTranslationSettings GetSettingsWithS3Binding(const TString& name) {
+    NSQLTranslation::TTranslationSettings settings;
+    NSQLTranslation::TTableBindingSettings bindSettings;
+    bindSettings.ClusterType = "s3";
+    bindSettings.Settings["cluster"] = "cluster";
+    bindSettings.Settings["path"] = "path";
+    bindSettings.Settings["format"] = "format";
+    bindSettings.Settings["compression"] = "ccompression";
+    bindSettings.Settings["bar"] = "1";
+    // schema is not validated in this test but should be valid YSON text
+    bindSettings.Settings["schema"] = R"__("[
+                        "StructType";
+                        [
+                            [
+                                "key";
+                                [
+                                    "DataType";
+                                    "String"
+                                ]
+                            ];
+                            [
+                                "subkey";
+                                [
+                                    "DataType";
+                                    "String"
+                                ]
+                            ];
+                            [
+                                "value";
+                                [
+                                    "DataType";
+                                    "String"
+                                ]
+                            ]
+    ]])__";
+    bindSettings.Settings["partitioned_by"] = "[\"key\", \"subkey\"]";
+    settings.Bindings[name] = bindSettings;
+    return settings;
+}
+
+inline void AstBfs(NYql::TAstNode const* root, std::function<bool (NYql::TAstNode const*)> visitor) {
+    std::deque<NYql::TAstNode const*> wishList{ root };
+    std::unordered_set<NYql::TAstNode const*> visited;
+    while(!wishList.empty()){
+        auto v = wishList.front();
+        wishList.pop_front();
+        if (!visitor(v))
+            return;
+        visited.insert(v);
+        if (v->IsList()) {
+            for (ui32 i = 0; i != v->GetChildrenCount(); ++i) {
+                auto child = v->GetChild(i);
+                if (visited.find(child) == visited.cend()) {
+                    wishList.push_back(child);
+                }
+            }
+        }
+    }
+}
+
+inline const NYql::TAstNode* FindNodeByChildAtomContent(const NYql::TAstNode* root, uint32_t childIndex, TStringBuf name){
+    const NYql::TAstNode* result = nullptr;
+    AstBfs(root, [&result, childIndex, name](auto v) {
+        if (v->IsList() && v->GetChildrenCount() > childIndex &&
+            v->GetChild(childIndex)->IsAtom() && v->GetChild(childIndex)->GetContent() == name) {
+            result = v;
+            return false;
+        }
+        return true; });
+    return result;
+}
diff --git a/ydb/library/yql/sql/v1/ut_antlr4/ya.make b/ydb/library/yql/sql/v1/ut_antlr4/ya.make
new file mode 100644
index 000000000000..35588ffcf004
--- /dev/null
+++ b/ydb/library/yql/sql/v1/ut_antlr4/ya.make
@@ -0,0 +1,20 @@
+UNITTEST_FOR(ydb/library/yql/sql/v1)
+
+SRCS(
+    sql_ut_antlr4.cpp
+    sql_match_recognize_ut.cpp
+)
+
+PEERDIR(
+    ydb/library/yql/public/udf/service/exception_policy
+    ydb/library/yql/core/sql_types
+    ydb/library/yql/sql
+    ydb/library/yql/sql/pg_dummy
+    ydb/library/yql/sql/v1/format
+)
+
+TIMEOUT(300)
+
+SIZE(MEDIUM)
+
+END()
diff --git a/ydb/library/yql/sql/v1/ya.make b/ydb/library/yql/sql/v1/ya.make
index 3d86e879d40d..12826b0bfda9 100644
--- a/ydb/library/yql/sql/v1/ya.make
+++ b/ydb/library/yql/sql/v1/ya.make
@@ -18,6 +18,8 @@ PEERDIR(
     ydb/library/yql/parser/proto_ast/gen/v1
     ydb/library/yql/parser/proto_ast/gen/v1_ansi
     ydb/library/yql/parser/proto_ast/gen/v1_proto_split
+    ydb/library/yql/parser/proto_ast/gen/v1_antlr4
+    ydb/library/yql/parser/proto_ast/gen/v1_ansi_antlr4
     ydb/library/yql/parser/pg_catalog
     ydb/library/yql/sql/v1/lexer
     ydb/library/yql/sql/v1/proto_parser
@@ -65,4 +67,5 @@ RECURSE(
 
 RECURSE_FOR_TESTS(
     ut
+    ut_antlr4
 )