YQL-20086 parser

commit_hash:dd605e5cde39ff07fdadf62f0c2364a8b12c8405

35 files changed, 1034 insertions, 987 deletions

diff --git a/yql/essentials/parser/common/antlr4/error_listener.cpp b/yql/essentials/parser/common/antlr4/error_listener.cpp
index 73c14175314..aee07e75bbd 100644
--- a/yql/essentials/parser/common/antlr4/error_listener.cpp
+++ b/yql/essentials/parser/common/antlr4/error_listener.cpp
@@ -8,78 +8,78 @@
 
 namespace antlr4 {
 
-    TVector<size_t> ToVector(const antlrcpp::BitSet& ambigAlts) {
-        TVector<size_t> result;
-        for (size_t i = 0; i < ambigAlts.size(); ++i) {
-            if (ambigAlts.test(i)) {
-                result.push_back(i);
-            }
+TVector<size_t> ToVector(const antlrcpp::BitSet& ambigAlts) {
+    TVector<size_t> result;
+    for (size_t i = 0; i < ambigAlts.size(); ++i) {
+        if (ambigAlts.test(i)) {
+            result.push_back(i);
         }
-        return result;
     }
-
-    YqlErrorListener::YqlErrorListener(NAST::IErrorCollector* errors, bool* error, bool isAmbiguityError)
-        : Errors_(errors)
-        , Error_(error)
-        , IsAmbiguityError_(isAmbiguityError)
-    {
+    return result;
+}
+
+YqlErrorListener::YqlErrorListener(NAST::IErrorCollector* errors, bool* error, bool isAmbiguityError)
+    : Errors_(errors)
+    , Error_(error)
+    , IsAmbiguityError_(isAmbiguityError)
+{
+}
+
+void 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());
+}
+
+void YqlErrorListener::reportAmbiguity(
+    Parser* recognizer,
+    const dfa::DFA& dfa,
+    size_t startIndex,
+    size_t stopIndex,
+    bool exact,
+    const antlrcpp::BitSet& ambigAlts,
+    atn::ATNConfigSet* configs)
+{
+    Y_UNUSED(configs);
+
+    size_t ruleIndex = dfa.atnStartState->ruleIndex;
+    std::string_view ruleName = recognizer->getRuleNames()[ruleIndex];
+
+    if ( // FIXME(YQL-20410): It is a known ambiguity, remove it when
+         // an expression (x NOT NULL) is a syntax error.
+        ruleName == "xor_subexpr" ||
+        // Known ambiguity, on ANTLR3 syntactic predicates were used.
+        ruleName == "neq_subexpr") {
+        return;
     }
 
-    void 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());
-    }
-
-    void YqlErrorListener::reportAmbiguity(
-        Parser* recognizer,
-        const dfa::DFA& dfa,
-        size_t startIndex,
-        size_t stopIndex,
-        bool exact,
-        const antlrcpp::BitSet& ambigAlts,
-        atn::ATNConfigSet* configs)
-    {
-        Y_UNUSED(configs);
-
-        size_t ruleIndex = dfa.atnStartState->ruleIndex;
-        std::string_view ruleName = recognizer->getRuleNames()[ruleIndex];
-
-        if (// FIXME(YQL-20410): It is a known ambiguity, remove it when
-            // an expression (x NOT NULL) is a syntax error.
-            ruleName == "xor_subexpr" ||
-            // Known ambiguity, on ANTLR3 syntactic predicates were used.
-            ruleName == "neq_subexpr") {
-            return;
-        }
-
-        TokenStream* tokens = recognizer->getTokenStream();
-        Token* start = tokens->get(startIndex);
-        Token* stop = tokens->get(stopIndex);
-
-        TString alternatives = JoinSeq(", ", ToVector(ambigAlts));
+    TokenStream* tokens = recognizer->getTokenStream();
+    Token* start = tokens->get(startIndex);
+    Token* stop = tokens->get(stopIndex);
 
-        NYql::TPosition startPos(start->getCharPositionInLine(), start->getLine(), "unknown");
-        NYql::TPosition stopPos(stop->getCharPositionInLine(), stop->getLine(), "unknown");
+    TString alternatives = JoinSeq(", ", ToVector(ambigAlts));
 
-        TString message = TStringBuilder()
-            << "An" << (exact ? " exactly " : " ")
-            << "ambiguous decision " << dfa.decision
-            << " at rule '" << ruleName << "'"
-            << " with conflicted alternatives {" << alternatives << "}";
+    NYql::TPosition startPos(start->getCharPositionInLine(), start->getLine(), "unknown");
+    NYql::TPosition stopPos(stop->getCharPositionInLine(), stop->getLine(), "unknown");
 
-        NYql::TIssue issue(std::move(startPos), std::move(stopPos), std::move(message));
+    TString message = TStringBuilder()
+                      << "An" << (exact ? " exactly " : " ")
+                      << "ambiguous decision " << dfa.decision
+                      << " at rule '" << ruleName << "'"
+                      << " with conflicted alternatives {" << alternatives << "}";
 
-        if (IsAmbiguityError_) {
-            *Error_ = true;
-            issue.SetCode(NYql::UNEXPECTED_ERROR, NYql::TSeverityIds::S_FATAL);
-        } else {
-            issue.SetCode(NYql::TIssuesIds::YQL_SYNTAX_AMBIGUITY, NYql::TSeverityIds::S_WARNING);
-        }
+    NYql::TIssue issue(std::move(startPos), std::move(stopPos), std::move(message));
 
-        Errors_->Report(std::move(issue));
+    if (IsAmbiguityError_) {
+        *Error_ = true;
+        issue.SetCode(NYql::UNEXPECTED_ERROR, NYql::TSeverityIds::S_FATAL);
+    } else {
+        issue.SetCode(NYql::TIssuesIds::YQL_SYNTAX_AMBIGUITY, NYql::TSeverityIds::S_WARNING);
     }
 
+    Errors_->Report(std::move(issue));
+}
+
 } // namespace antlr4
diff --git a/yql/essentials/parser/common/antlr4/error_listener.h b/yql/essentials/parser/common/antlr4/error_listener.h
index 3d8f6af8a6b..a5cb3c9ff4e 100644
--- a/yql/essentials/parser/common/antlr4/error_listener.h
+++ b/yql/essentials/parser/common/antlr4/error_listener.h
@@ -6,27 +6,27 @@
 
 namespace antlr4 {
 
-    class ANTLR4CPP_PUBLIC YqlErrorListener: public BaseErrorListener {
-        NAST::IErrorCollector* Errors_;
-        bool* Error_;
-        const bool IsAmbiguityError_;
-
-    public:
-        YqlErrorListener(NAST::IErrorCollector* errors, bool* error, bool isAmbiguityError = false);
-
-        virtual void syntaxError(
-            Recognizer* recognizer, Token* offendingSymbol,
-            size_t line, size_t charPositionInLine,
-            const std::string& msg, std::exception_ptr e) override;
-
-        void reportAmbiguity(
-            Parser* recognizer,
-            const dfa::DFA& dfa,
-            size_t startIndex,
-            size_t stopIndex,
-            bool exact,
-            const antlrcpp::BitSet& ambigAlts,
-            atn::ATNConfigSet* configs) override;
-    };
+class ANTLR4CPP_PUBLIC YqlErrorListener: public BaseErrorListener {
+    NAST::IErrorCollector* Errors_;
+    bool* Error_;
+    const bool IsAmbiguityError_;
+
+public:
+    YqlErrorListener(NAST::IErrorCollector* errors, bool* error, bool isAmbiguityError = false);
+
+    virtual void syntaxError(
+        Recognizer* recognizer, Token* offendingSymbol,
+        size_t line, size_t charPositionInLine,
+        const std::string& msg, std::exception_ptr e) override;
+
+    void reportAmbiguity(
+        Parser* recognizer,
+        const dfa::DFA& dfa,
+        size_t startIndex,
+        size_t stopIndex,
+        bool exact,
+        const antlrcpp::BitSet& ambigAlts,
+        atn::ATNConfigSet* configs) override;
+};
 
 } // namespace antlr4
diff --git a/yql/essentials/parser/common/antlr4/lexer_tokens_collector.h b/yql/essentials/parser/common/antlr4/lexer_tokens_collector.h
index 2e5ef52f48e..672637d72fe 100644
--- a/yql/essentials/parser/common/antlr4/lexer_tokens_collector.h
+++ b/yql/essentials/parser/common/antlr4/lexer_tokens_collector.h
@@ -9,55 +9,55 @@
 
 namespace NAST {
 
-    template <typename TLexer>
-    class TLexerTokensCollector4 {
-    public:
-        TLexerTokensCollector4(TStringBuf data, const TString& queryName = "query")
-            : QueryName(queryName)
-            , InputStream(std::string(data))
-            , Lexer(&InputStream)
-        {
-        }
-
-        void CollectTokens(NAST::IErrorCollector& errors, const NSQLTranslation::ILexer::TTokenCallback& onNextToken) {
-            try {
-                bool error = false;
-                typename antlr4::YqlErrorListener listener(&errors, &error);
-                Lexer.removeErrorListeners();
-                Lexer.addErrorListener(&listener);
-
-                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;
-                    }
+template <typename TLexer>
+class TLexerTokensCollector4 {
+public:
+    TLexerTokensCollector4(TStringBuf data, const TString& queryName = "query")
+        : QueryName(queryName)
+        , InputStream(std::string(data))
+        , Lexer(&InputStream)
+    {
+    }
+
+    void CollectTokens(NAST::IErrorCollector& errors, const NSQLTranslation::ILexer::TTokenCallback& onNextToken) {
+        try {
+            bool error = false;
+            typename antlr4::YqlErrorListener listener(&errors, &error);
+            Lexer.removeErrorListeners();
+            Lexer.addErrorListener(&listener);
+
+            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 NAST::TTooManyErrors&) {
-            } catch (...) {
-                errors.Error(0, 0, CurrentExceptionMessage());
             }
+        } catch (const NAST::TTooManyErrors&) {
+        } catch (...) {
+            errors.Error(0, 0, CurrentExceptionMessage());
         }
+    }
 
-    private:
-        TString GetTokenName(size_t type) const {
-            auto res = Lexer.getVocabulary().getSymbolicName(type);
-            if (res != "") {
-                return TString(res);
-            }
-            return TString(NAST::INVALID_TOKEN_NAME);
+private:
+    TString GetTokenName(size_t type) const {
+        auto res = Lexer.getVocabulary().getSymbolicName(type);
+        if (res != "") {
+            return TString(res);
         }
+        return TString(NAST::INVALID_TOKEN_NAME);
+    }
 
-        TString QueryName;
-        antlr4::ANTLRInputStream InputStream;
-        TLexer Lexer;
-    };
+    TString QueryName;
+    antlr4::ANTLRInputStream InputStream;
+    TLexer Lexer;
+};
 
 } // namespace NAST
diff --git a/yql/essentials/parser/common/antlr4/ya.make b/yql/essentials/parser/common/antlr4/ya.make
index d74107fe119..5468514d977 100644
--- a/yql/essentials/parser/common/antlr4/ya.make
+++ b/yql/essentials/parser/common/antlr4/ya.make
@@ -1,5 +1,7 @@
 LIBRARY()
 
+ENABLE(YQL_STYLE_CPP)
+
 PEERDIR(
     contrib/libs/antlr4_cpp_runtime
     yql/essentials/parser/common
diff --git a/yql/essentials/parser/common/error.cpp b/yql/essentials/parser/common/error.cpp
index b6b087631c7..dcddf57d7ea 100644
--- a/yql/essentials/parser/common/error.cpp
+++ b/yql/essentials/parser/common/error.cpp
@@ -2,41 +2,41 @@
 
 namespace NAST {
 
-    IErrorCollector::IErrorCollector(size_t maxErrors)
-        : MaxErrors_(maxErrors)
-        , NumErrors_(0)
-    {
-        Y_ENSURE(0 < MaxErrors_);
-    }
-
-    IErrorCollector::~IErrorCollector()
-    {
-    }
-
-    void IErrorCollector::Error(ui32 line, ui32 col, const TString& message) {
-        GuardTooManyErrors();
-        AddError(line, col, message);
+IErrorCollector::IErrorCollector(size_t maxErrors)
+    : MaxErrors_(maxErrors)
+    , NumErrors_(0)
+{
+    Y_ENSURE(0 < MaxErrors_);
+}
+
+IErrorCollector::~IErrorCollector()
+{
+}
+
+void IErrorCollector::Error(ui32 line, ui32 col, const TString& message) {
+    GuardTooManyErrors();
+    AddError(line, col, message);
+    ++NumErrors_;
+}
+
+void IErrorCollector::Report(NYql::TIssue&& issue) {
+    GuardTooManyErrors();
+    bool isError = issue.GetSeverity() >= NYql::TSeverityIds::S_WARNING;
+    AddIssue(std::forward<NYql::TIssue>(issue));
+    if (isError) {
         ++NumErrors_;
     }
+}
 
-    void IErrorCollector::Report(NYql::TIssue&& issue) {
-        GuardTooManyErrors();
-        bool isError = issue.GetSeverity() >= NYql::TSeverityIds::S_WARNING;
-        AddIssue(std::forward<NYql::TIssue>(issue));
-        if (isError) {
-            ++NumErrors_;
-        }
+void IErrorCollector::GuardTooManyErrors() {
+    if (NumErrors_ + 1 == MaxErrors_) {
+        AddError(0, 0, "Too many errors");
+        ++NumErrors_;
     }
 
-    void IErrorCollector::GuardTooManyErrors() {
-        if (NumErrors_ + 1 == MaxErrors_) {
-            AddError(0, 0, "Too many errors");
-            ++NumErrors_;
-        }
-
-        if (NumErrors_ >= MaxErrors_) {
-            ythrow TTooManyErrors() << "Too many errors";
-        }
+    if (NumErrors_ >= MaxErrors_) {
+        ythrow TTooManyErrors() << "Too many errors";
     }
+}
 
 } // namespace NAST
diff --git a/yql/essentials/parser/common/error.h b/yql/essentials/parser/common/error.h
index 81a920a2809..0214fe18790 100644
--- a/yql/essentials/parser/common/error.h
+++ b/yql/essentials/parser/common/error.h
@@ -6,33 +6,33 @@
 #include <util/generic/fwd.h>
 
 namespace NAST {
-    static const char* INVALID_TOKEN_NAME = "nothing";
-    static const char* ABSENCE = " absence";
+static const char* INVALID_TOKEN_NAME = "nothing";
+static const char* ABSENCE = " absence";
 
-    class TTooManyErrors: public yexception {
-    };
+class TTooManyErrors: public yexception {
+};
 
-    class IErrorCollector {
-    public:
-        explicit IErrorCollector(size_t maxErrors);
-        virtual ~IErrorCollector();
+class IErrorCollector {
+public:
+    explicit IErrorCollector(size_t maxErrors);
+    virtual ~IErrorCollector();
 
-        // throws TTooManyErrors
-        void Error(ui32 line, ui32 col, const TString& message);
+    // throws TTooManyErrors
+    void Error(ui32 line, ui32 col, const TString& message);
 
-        // throws TTooManyErrors
-        void Report(NYql::TIssue&& issue);
+    // throws TTooManyErrors
+    void Report(NYql::TIssue&& issue);
 
-    private:
-        void GuardTooManyErrors();
+private:
+    void GuardTooManyErrors();
 
-        virtual void AddError(ui32 line, ui32 col, const TString& message) = 0;
+    virtual void AddError(ui32 line, ui32 col, const TString& message) = 0;
 
-        virtual void AddIssue(NYql::TIssue&& issue) = 0;
+    virtual void AddIssue(NYql::TIssue&& issue) = 0;
 
-    protected:
-        const size_t MaxErrors_;
-        size_t NumErrors_;
-    };
+protected:
+    const size_t MaxErrors_;
+    size_t NumErrors_;
+};
 
 } // namespace NAST
diff --git a/yql/essentials/parser/common/issue.h b/yql/essentials/parser/common/issue.h
index 3a17252cbdb..2dfa340cdf3 100644
--- a/yql/essentials/parser/common/issue.h
+++ b/yql/essentials/parser/common/issue.h
@@ -8,29 +8,29 @@
 
 namespace NSQLTranslation {
 
-    class TErrorCollectorOverIssues: public NAST::IErrorCollector {
-    public:
-        TErrorCollectorOverIssues(NYql::TIssues& issues, size_t maxErrors, const TString& file)
-            : IErrorCollector(maxErrors)
-            , Issues_(issues)
-            , File_(file)
-        {
-        }
-
-    private:
-        void AddError(ui32 line, ui32 col, const TString& message) override {
-            Issues_.AddIssue(NYql::TPosition(col, line, File_), message);
-        }
-
-        void AddIssue(NYql::TIssue&& issue) override {
-            issue.Position.File = File_;
-            issue.EndPosition.File = File_;
-            Issues_.AddIssue(std::forward<NYql::TIssue>(issue));
-        }
-
-    private:
-        NYql::TIssues& Issues_;
-        const TString File_;
-    };
+class TErrorCollectorOverIssues: public NAST::IErrorCollector {
+public:
+    TErrorCollectorOverIssues(NYql::TIssues& issues, size_t maxErrors, const TString& file)
+        : IErrorCollector(maxErrors)
+        , Issues_(issues)
+        , File_(file)
+    {
+    }
+
+private:
+    void AddError(ui32 line, ui32 col, const TString& message) override {
+        Issues_.AddIssue(NYql::TPosition(col, line, File_), message);
+    }
+
+    void AddIssue(NYql::TIssue&& issue) override {
+        issue.Position.File = File_;
+        issue.EndPosition.File = File_;
+        Issues_.AddIssue(std::forward<NYql::TIssue>(issue));
+    }
+
+private:
+    NYql::TIssues& Issues_;
+    const TString File_;
+};
 
 } // namespace NSQLTranslation
diff --git a/yql/essentials/parser/common/ya.make b/yql/essentials/parser/common/ya.make
index 290ae7be8b5..fe825d46d94 100644
--- a/yql/essentials/parser/common/ya.make
+++ b/yql/essentials/parser/common/ya.make
@@ -1,5 +1,7 @@
 LIBRARY()
 
+ENABLE(YQL_STYLE_CPP)
+
 PEERDIR(
     yql/essentials/public/issue
     yql/essentials/core/issue
diff --git a/yql/essentials/parser/lexer_common/hints.cpp b/yql/essentials/parser/lexer_common/hints.cpp
index 275ca165e92..ddc071d30fa 100644
--- a/yql/essentials/parser/lexer_common/hints.cpp
+++ b/yql/essentials/parser/lexer_common/hints.cpp
@@ -35,7 +35,8 @@ public:
         : QueryFile_(queryFile)
         , Hints_(hints)
         , Utf8Aware_(utf8Aware)
-    {}
+    {
+    }
 
     TPosition ExtractPosition(const TParsedToken& token) const {
         return TPosition(token.LinePos + 1, token.Line, QueryFile_);
@@ -74,13 +75,12 @@ private:
     const bool Utf8Aware_;
 };
 
-}
+} // namespace
 
 bool CollectSqlHints(ILexer& lexer, const TString& query, const TString& queryName,
-    const TString& queryFile, TSQLHints& hints, NYql::TIssues& issues, size_t maxErrors, bool utf8Aware) {
+                     const TString& queryFile, TSQLHints& hints, NYql::TIssues& issues, size_t maxErrors, bool utf8Aware) {
     TTokenProcessor tp(queryFile, hints, utf8Aware);
     return lexer.Tokenize(query, queryName, [&tp](TParsedToken&& token) { tp.ProcessToken(std::move(token)); }, issues, maxErrors);
 }
 
-
-}
+} // namespace NSQLTranslation
diff --git a/yql/essentials/parser/lexer_common/hints.h b/yql/essentials/parser/lexer_common/hints.h
index a59b43aac2e..1366e05d951 100644
--- a/yql/essentials/parser/lexer_common/hints.h
+++ b/yql/essentials/parser/lexer_common/hints.h
@@ -30,12 +30,10 @@ using TSQLHints = TMap<NYql::TPosition, TVector<TSQLHint>>;
 // in this case TSQLHints will consist of single entry with position of SELECT token
 
 bool CollectSqlHints(ILexer& lexer, const TString& query, const TString& queryName,
-    const TString& queryFile, TSQLHints& hints, NYql::TIssues& issues, size_t maxErrors, bool utf8Aware);
+                     const TString& queryFile, TSQLHints& hints, NYql::TIssues& issues, size_t maxErrors, bool utf8Aware);
 
-}
+} // namespace NSQLTranslation
 
 Y_DECLARE_OUT_SPEC(inline, NSQLTranslation::TSQLHint, stream, value) {
     value.Out(stream);
 }
-
-
diff --git a/yql/essentials/parser/lexer_common/lexer.cpp b/yql/essentials/parser/lexer_common/lexer.cpp
index c93dd35bd48..7c7dd5bda13 100644
--- a/yql/essentials/parser/lexer_common/lexer.cpp
+++ b/yql/essentials/parser/lexer_common/lexer.cpp
@@ -7,11 +7,12 @@ namespace NSQLTranslation {
 
 namespace {
 
-class TDummyLexer : public ILexer {
+class TDummyLexer: public ILexer {
 public:
     TDummyLexer(const TString& name)
         : Name_(name)
-    {}
+    {
+    }
 
     bool Tokenize(const TString& query, const TString& queryName, const TTokenCallback& onNextToken, NYql::TIssues& issues, size_t maxErrors) final {
         Y_UNUSED(query);
@@ -30,7 +31,8 @@ class TDummyFactory: public ILexerFactory {
 public:
     TDummyFactory(const TString& name)
         : Name_(name)
-    {}
+    {
+    }
 
     ILexer::TPtr MakeLexer() const final {
         return MakeHolder<TDummyLexer>(Name_);
@@ -40,10 +42,10 @@ private:
     const TString Name_;
 };
 
-}
+} // namespace
 
 TLexerFactoryPtr MakeDummyLexerFactory(const TString& name) {
     return MakeIntrusive<TDummyFactory>(name);
 }
 
-}
+} // namespace NSQLTranslation
diff --git a/yql/essentials/parser/lexer_common/lexer.h b/yql/essentials/parser/lexer_common/lexer.h
index 4de7eedb836..b56e5c1d424 100644
--- a/yql/essentials/parser/lexer_common/lexer.h
+++ b/yql/essentials/parser/lexer_common/lexer.h
@@ -10,7 +10,7 @@ namespace NYql {
 
 class TIssues;
 
-}
+} // namespace NYql
 
 namespace NSQLTranslation {
 
@@ -39,7 +39,7 @@ using TParsedTokenList = TVector<TParsedToken>;
 IOutputStream& OutputTokens(IOutputStream& out, TParsedTokenList::const_iterator begin, TParsedTokenList::const_iterator end);
 bool Tokenize(ILexer& lexer, const TString& query, const TString& queryName, TParsedTokenList& tokens, NYql::TIssues& issues, size_t maxErrors);
 
-class ILexerFactory : public TThrRefBase {
+class ILexerFactory: public TThrRefBase {
 public:
     virtual ~ILexerFactory() = default;
 
@@ -50,5 +50,4 @@ using TLexerFactoryPtr = TIntrusivePtr<ILexerFactory>;
 
 TLexerFactoryPtr MakeDummyLexerFactory(const TString& name);
 
-}
-
+} // namespace NSQLTranslation
diff --git a/yql/essentials/parser/lexer_common/parse_hints_impl.cpp b/yql/essentials/parser/lexer_common/parse_hints_impl.cpp
index 10a0257e5df..835d69a0ab2 100644
--- a/yql/essentials/parser/lexer_common/parse_hints_impl.cpp
+++ b/yql/essentials/parser/lexer_common/parse_hints_impl.cpp
@@ -100,6 +100,6 @@ TVector<TSQLHint> ParseSqlHints(NYql::TPosition commentPos, const TStringBuf& co
     return result;
 }
 
-}
+} // namespace NDetail
 
-}
+} // namespace NSQLTranslation
diff --git a/yql/essentials/parser/lexer_common/parse_hints_impl.h b/yql/essentials/parser/lexer_common/parse_hints_impl.h
index fdc8536453d..efe6ab4479c 100644
--- a/yql/essentials/parser/lexer_common/parse_hints_impl.h
+++ b/yql/essentials/parser/lexer_common/parse_hints_impl.h
@@ -8,6 +8,6 @@ namespace NDetail {
 
 TVector<TSQLHint> ParseSqlHints(NYql::TPosition commentPos, const TStringBuf& comment, bool utf8Aware);
 
-}
+} // namespace NDetail
 
-}
+} // namespace NSQLTranslation
diff --git a/yql/essentials/parser/lexer_common/tokens.cpp b/yql/essentials/parser/lexer_common/tokens.cpp
index 014a815e435..29b41153ddb 100644
--- a/yql/essentials/parser/lexer_common/tokens.cpp
+++ b/yql/essentials/parser/lexer_common/tokens.cpp
@@ -17,4 +17,4 @@ bool Tokenize(ILexer& lexer, const TString& query, const TString& queryName, TPa
     return lexer.Tokenize(query, queryName, onNextToken, issues, maxErrors);
 }
 
-}
+} // namespace NSQLTranslation
diff --git a/yql/essentials/parser/lexer_common/ut/hints_ut.cpp b/yql/essentials/parser/lexer_common/ut/hints_ut.cpp
index 2542c1ac266..0a674451ae1 100644
--- a/yql/essentials/parser/lexer_common/ut/hints_ut.cpp
+++ b/yql/essentials/parser/lexer_common/ut/hints_ut.cpp
@@ -28,17 +28,17 @@ 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);
-        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(Basic) {
+    TString query = "/*+ some() */ SELECT /*+ foo(one) */ --+ bar(two)";
+    auto hintsWithPos = CollectHints(query);
+    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_SUITE(TLexerHintsTests)
diff --git a/yql/essentials/parser/lexer_common/ut/parse_hints_ut.cpp b/yql/essentials/parser/lexer_common/ut/parse_hints_ut.cpp
index f2f4ebca819..206a4c7ca68 100644
--- a/yql/essentials/parser/lexer_common/ut/parse_hints_ut.cpp
+++ b/yql/essentials/parser/lexer_common/ut/parse_hints_ut.cpp
@@ -13,26 +13,26 @@ void CheckParse(TStringBuf comment, TStringBuf expected) {
 }
 
 Y_UNIT_TEST_SUITE(TParseTests) {
-    Y_UNIT_TEST(NoPlusInComment) {
-        CheckParse("/* foo(bar) */", "");
-        CheckParse("-- foo(bar)\n", "");
-    }
-
-    Y_UNIT_TEST(Basic) {
-        TStringBuf comment = "/*+Foo( Bar 0Baz*) test\nFoo1(Bar1    Bar2)\n Foo2()*/";
-        TStringBuf expected = R"raw("Foo":{"Bar","0Baz*"},"Foo1":{"Bar1","Bar2"},"Foo2":{})raw";
-        CheckParse(comment, expected);
-    }
-
-    Y_UNIT_TEST(Quoted) {
-        TStringBuf comment = "/*+Foo('Bar' Baz 'Bar'' quote')*/";
-        TStringBuf expected = R"raw("Foo":{"Bar","Baz","Bar' quote"})raw";
-        CheckParse(comment, expected);
-    }
-
-    Y_UNIT_TEST(MissingSpace) {
-        TStringBuf comment = "/*+Foo()Bar(x)*/";
-        TStringBuf expected = R"raw("Foo":{})raw";
-        CheckParse(comment, expected);
-    }
+Y_UNIT_TEST(NoPlusInComment) {
+    CheckParse("/* foo(bar) */", "");
+    CheckParse("-- foo(bar)\n", "");
 }
+
+Y_UNIT_TEST(Basic) {
+    TStringBuf comment = "/*+Foo( Bar 0Baz*) test\nFoo1(Bar1    Bar2)\n Foo2()*/";
+    TStringBuf expected = R"raw("Foo":{"Bar","0Baz*"},"Foo1":{"Bar1","Bar2"},"Foo2":{})raw";
+    CheckParse(comment, expected);
+}
+
+Y_UNIT_TEST(Quoted) {
+    TStringBuf comment = "/*+Foo('Bar' Baz 'Bar'' quote')*/";
+    TStringBuf expected = R"raw("Foo":{"Bar","Baz","Bar' quote"})raw";
+    CheckParse(comment, expected);
+}
+
+Y_UNIT_TEST(MissingSpace) {
+    TStringBuf comment = "/*+Foo()Bar(x)*/";
+    TStringBuf expected = R"raw("Foo":{})raw";
+    CheckParse(comment, expected);
+}
+} // Y_UNIT_TEST_SUITE(TParseTests)
diff --git a/yql/essentials/parser/lexer_common/ut/ya.make b/yql/essentials/parser/lexer_common/ut/ya.make
index ab4a9d96ea9..591872e21f1 100644
--- a/yql/essentials/parser/lexer_common/ut/ya.make
+++ b/yql/essentials/parser/lexer_common/ut/ya.make
@@ -1,5 +1,7 @@
 UNITTEST_FOR(yql/essentials/parser/lexer_common)
 
+ENABLE(YQL_STYLE_CPP)
+
 PEERDIR(
     yql/essentials/sql/v1/lexer
     yql/essentials/sql/v1/lexer/antlr4
diff --git a/yql/essentials/parser/lexer_common/ya.make b/yql/essentials/parser/lexer_common/ya.make
index 14573434c47..6434e770444 100644
--- a/yql/essentials/parser/lexer_common/ya.make
+++ b/yql/essentials/parser/lexer_common/ya.make
@@ -1,5 +1,7 @@
 LIBRARY()
 
+ENABLE(YQL_STYLE_CPP)
+
 PEERDIR(
     yql/essentials/public/issue
 )
diff --git a/yql/essentials/parser/pg_catalog/catalog.cpp b/yql/essentials/parser/pg_catalog/catalog.cpp
index 37489bd25aa..003849e2897 100644
--- a/yql/essentials/parser/pg_catalog/catalog.cpp
+++ b/yql/essentials/parser/pg_catalog/catalog.cpp
@@ -30,21 +30,20 @@ constexpr ui32 RegOperOid = 2203;
 constexpr ui32 RegOperatorOid = 2204;
 constexpr ui32 RegClassOid = 2205;
 constexpr ui32 RegTypeOid = 2206;
-//constexpr ui32 AnyElementOid = 2283;
-//constexpr ui32 AnyNonArrayOid = 2776;
+// constexpr ui32 AnyElementOid = 2283;
+// constexpr ui32 AnyNonArrayOid = 2776;
 constexpr ui32 RegConfigOid = 3734;
 constexpr ui32 RegDictionaryOid = 3769;
 constexpr ui32 RegNamespaceOid = 4089;
 constexpr ui32 RegRoleOid = 4096;
-//constexpr ui32 AnyCompatibleOid = 5077;
-//constexpr ui32 AnyCompatibleArrayOid = 5078;
-//constexpr ui32 AnyCompatibleNonArrayOid = 5079;
+// constexpr ui32 AnyCompatibleOid = 5077;
+// constexpr ui32 AnyCompatibleArrayOid = 5078;
+// constexpr ui32 AnyCompatibleNonArrayOid = 5079;
 
 // See GetCCHashEqFuncs in PG sources
 // https://doxygen.postgresql.org/catcache_8c.html#a8a2dc395011dba02c083bfbf6b87ce6c
-const THashSet<ui32> regClasses({
-    RegProcOid, RegProcedureOid, RegOperOid, RegOperatorOid, RegClassOid, RegTypeOid,
-    RegConfigOid, RegDictionaryOid, RegRoleOid, RegNamespaceOid});
+const THashSet<ui32> regClasses({RegProcOid, RegProcedureOid, RegOperOid, RegOperatorOid, RegClassOid, RegTypeOid,
+                                 RegConfigOid, RegDictionaryOid, RegRoleOid, RegNamespaceOid});
 
 using TOperators = THashMap<ui32, TOperDesc>;
 
@@ -319,8 +318,7 @@ bool ValidateOperArgs(const TOperDesc& d, const TVector<ui32>& argTypeIds, const
         ui32 expectedArgType;
         if (d.Kind == EOperKind::RightUnary || (d.Kind == EOperKind::Binary && i == 0)) {
             expectedArgType = d.LeftType;
-        }
-        else {
+        } else {
             expectedArgType = d.RightType;
         }
 
@@ -337,17 +335,18 @@ struct TLazyOperInfo {
     TString Negate;
 };
 
-class TOperatorsParser : public TParser {
+class TOperatorsParser: public TParser {
 public:
     TOperatorsParser(TOperators& operators, const THashMap<TString, ui32>& typeByName, const TTypes& types,
-        const THashMap<TString, TVector<ui32>>& procByName, const TProcs& procs, THashMap<ui32, TLazyOperInfo>& lazyInfos)
+                     const THashMap<TString, TVector<ui32>>& procByName, const TProcs& procs, THashMap<ui32, TLazyOperInfo>& lazyInfos)
         : Operators_(operators)
         , TypeByName_(typeByName)
         , Types_(types)
         , ProcByName_(procByName)
         , Procs_(procs)
         , LazyInfos_(lazyInfos)
-    {}
+    {
+    }
 
     void OnKey(const TString& key, const TString& value) override {
         if (key == "oid") {
@@ -442,12 +441,13 @@ private:
     TString LastCom_;
 };
 
-class TProcsParser : public TParser {
+class TProcsParser: public TParser {
 public:
     TProcsParser(TProcs& procs, const THashMap<TString, ui32>& typeByName)
         : Procs_(procs)
         , TypeByName_(typeByName)
-    {}
+    {
+    }
 
     void OnKey(const TString& key, const TString& value) override {
         if (key == "oid") {
@@ -610,12 +610,13 @@ struct TLazyTypeInfo {
     TString SubscriptFunc;
 };
 
-class TTypesParser : public TParser {
+class TTypesParser: public TParser {
 public:
     TTypesParser(TTypes& types, THashMap<ui32, TLazyTypeInfo>& lazyInfos)
         : Types_(types)
         , LazyInfos_(lazyInfos)
-    {}
+    {
+    }
 
     void OnKey(const TString& key, const TString& value) override {
         if (key == "oid") {
@@ -651,22 +652,30 @@ public:
             Y_ENSURE(value.size() == 1);
             const auto typType = value[0];
 
-            LastType_.TypType =
-                    (typType == 'b') ? ETypType::Base :
-                    (typType == 'c') ? ETypType::Composite :
-                    (typType == 'd') ? ETypType::Domain :
-                    (typType == 'e') ? ETypType::Enum :
-                    (typType == 'm') ? ETypType::Multirange :
-                    (typType == 'p') ? ETypType::Pseudo :
-                    (typType == 'r') ? ETypType::Range :
-                    ythrow yexception() << "Unknown typtype value: " << value;
+            switch (typType) {
+            case 'b':
+            case 'c':
+            case 'd':
+            case 'e':
+            case 'm':
+            case 'p':
+            case 'r':
+                LastType_.TypType = (ETypType)typType;
+                break;
+            default:
+                throw yexception() << "Unknown typtype value: " << typType;
+            }
         } else if (key == "typcollation") {
             // hardcode collations for now. There are only three of 'em in .dat file
-            LastType_.TypeCollation =
-                    (value == "default") ? DefaultCollationOid :
-                    (value == "C") ? C_CollationOid :
-                    (value == "POSIX") ? PosixCollationOid :
-                    ythrow yexception() << "Unknown typcollation value: " << value;
+            if (value == "default") {
+                LastType_.TypeCollation = DefaultCollationOid;
+            } else if (value == "C") {
+                LastType_.TypeCollation = C_CollationOid;
+            }  else if (value == "POSIX") {
+                LastType_.TypeCollation = PosixCollationOid;
+            } else {
+                throw yexception() << "Unknown typcollation value: " << value;
+            }
         } else if (key == "typelem") {
             LastLazyTypeInfo_.ElementType = value; // resolve later
         } else if (key == "typinput") {
@@ -689,7 +698,7 @@ public:
             } else if (value == "t" || value == "FLOAT8PASSBYVAL") {
                 LastType_.PassByValue = true;
             } else {
-                ythrow yexception() << "Unknown typbyval value: " << value;
+                throw yexception() << "Unknown typbyval value: " << value;
             }
         } else if (key == "typispreferred") {
             LastType_.IsPreferred = (value == "t");
@@ -735,16 +744,17 @@ private:
     TLazyTypeInfo LastLazyTypeInfo_;
 };
 
-class TCastsParser : public TParser {
+class TCastsParser: public TParser {
 public:
     TCastsParser(TCasts& casts, const THashMap<TString, ui32>& typeByName, const TTypes& types,
-        const THashMap<TString, TVector<ui32>>& procByName, const TProcs& procs)
+                 const THashMap<TString, TVector<ui32>>& procByName, const TProcs& procs)
         : Casts_(casts)
         , TypeByName_(typeByName)
         , Types_(types)
         , ProcByName_(procByName)
         , Procs_(procs)
-    {}
+    {
+    }
 
     void OnKey(const TString& key, const TString& value) override {
         if (key == "castsource") {
@@ -807,17 +817,21 @@ public:
             } else if (value == "b") {
                 LastCast_.Method = ECastMethod::Binary;
             } else {
-                ythrow yexception() << "Unknown castmethod value: " << value;
+                throw yexception() << "Unknown castmethod value: " << value;
             }
         } else if (key == "castcontext") {
             Y_ENSURE(value.size() == 1);
             const auto castCtx = value[0];
 
-            LastCast_.CoercionCode =
-                    (castCtx == 'i') ? ECoercionCode::Implicit :
-                    (castCtx == 'a') ? ECoercionCode::Assignment :
-                    (castCtx == 'e') ? ECoercionCode::Explicit :
-                    ythrow yexception() << "Unknown castcontext value: " << value;
+            switch (castCtx) {
+            case 'i':
+            case 'a':
+            case 'e':
+                LastCast_.CoercionCode = (ECoercionCode)castCtx;
+                break;
+            default:
+                throw yexception() << "Unknown castcontext value: " << castCtx;
+            }
         }
     }
 
@@ -841,16 +855,17 @@ private:
     bool IsSupported_ = true;
 };
 
-class TAggregationsParser : public TParser {
+class TAggregationsParser: public TParser {
 public:
     TAggregationsParser(TAggregations& aggregations, const THashMap<TString, ui32>& typeByName,
-        const TTypes& types, const THashMap<TString, TVector<ui32>>& procByName, const TProcs& procs)
+                        const TTypes& types, const THashMap<TString, TVector<ui32>>& procByName, const TProcs& procs)
         : Aggregations_(aggregations)
         , TypeByName_(typeByName)
         , Types_(types)
         , ProcByName_(procByName)
         , Procs_(procs)
-    {}
+    {
+    }
 
     void OnKey(const TString& key, const TString& value) override {
         Y_UNUSED(ProcByName_);
@@ -878,12 +893,13 @@ public:
             } else if (value == "h") {
                 LastAggregation_.Kind = EAggKind::Hypothetical;
             } else {
-                ythrow yexception() << "Unknown aggkind value: " << value;
+                throw yexception() << "Unknown aggkind value: " << value;
             }
         } else if (key == "agginitval") {
             LastAggregation_.InitValue = value;
         } else if (key == "aggfinalextra") {
-            LastAggregation_.FinalExtra = (value == "t");;
+            LastAggregation_.FinalExtra = (value == "t");
+            ;
         } else if (key == "aggnumdirectargs") {
             LastAggregation_.NumDirectArgs = FromString<ui32>(value);
         }
@@ -1050,11 +1066,12 @@ private:
     TString LastDeserializeFunc_;
 };
 
-class TOpFamiliesParser : public TParser {
+class TOpFamiliesParser: public TParser {
 public:
     TOpFamiliesParser(TOpFamilies& opFamilies)
         : OpFamilies_(opFamilies)
-    {}
+    {
+    }
 
     void OnKey(const TString& key, const TString& value) override {
         if (key == "oid") {
@@ -1097,14 +1114,15 @@ private:
     bool IsSupported_ = true;
 };
 
-class TOpClassesParser : public TParser {
+class TOpClassesParser: public TParser {
 public:
     TOpClassesParser(TOpClasses& opClasses, const THashMap<TString, ui32>& typeByName,
-                     const TOpFamilies &opFamilies)
-            : OpClasses_(opClasses)
-            , TypeByName_(typeByName)
-            , OpFamilies_(opFamilies)
-    {}
+                     const TOpFamilies& opFamilies)
+        : OpClasses_(opClasses)
+        , TypeByName_(typeByName)
+        , OpFamilies_(opFamilies)
+    {
+    }
 
     void OnKey(const TString& key, const TString& value) override {
         if (key == "opcmethod") {
@@ -1135,24 +1153,24 @@ public:
         }
     }
 
-void OnFinish() override {
-    // Only default opclasses are used so far
-    if (IsSupported_ && IsDefault_) {
-        Y_ENSURE(!LastOpClass_.Name.empty());
+    void OnFinish() override {
+        // Only default opclasses are used so far
+        if (IsSupported_ && IsDefault_) {
+            Y_ENSURE(!LastOpClass_.Name.empty());
 
-        const auto key = std::make_pair(LastOpClass_.Method, LastOpClass_.TypeId);
+            const auto key = std::make_pair(LastOpClass_.Method, LastOpClass_.TypeId);
 
-        if (OpClasses_.contains(key)) {
-            throw yexception() << "Duplicate opclass: (" << (key.first == EOpClassMethod::Btree ? "btree" : "hash")
-                               << ", " << key.second << ")";
+            if (OpClasses_.contains(key)) {
+                throw yexception() << "Duplicate opclass: (" << (key.first == EOpClassMethod::Btree ? "btree" : "hash")
+                                   << ", " << key.second << ")";
+            }
+            OpClasses_[key] = LastOpClass_;
         }
-        OpClasses_[key] = LastOpClass_;
-    }
 
-    IsSupported_ = true;
-    IsDefault_ = true;
-    LastOpClass_ = TOpClassDesc();
-}
+        IsSupported_ = true;
+        IsDefault_ = true;
+        LastOpClass_ = TOpClassDesc();
+    }
 
 private:
     TOpClasses& OpClasses_;
@@ -1165,18 +1183,19 @@ private:
     bool IsDefault_ = true;
 };
 
-class TAmOpsParser : public TParser {
+class TAmOpsParser: public TParser {
 public:
     TAmOpsParser(TAmOps& amOps, const THashMap<TString, ui32>& typeByName, const TTypes& types,
-        const THashMap<TString, TVector<ui32>>& operatorsByName, const TOperators& operators,
-        const TOpFamilies &opFamilies)
+                 const THashMap<TString, TVector<ui32>>& operatorsByName, const TOperators& operators,
+                 const TOpFamilies& opFamilies)
         : AmOps_(amOps)
         , TypeByName_(typeByName)
         , Types_(types)
         , OperatorsByName_(operatorsByName)
         , Operators_(operators)
         , OpFamilies_(opFamilies)
-    {}
+    {
+    }
 
     void OnKey(const TString& key, const TString& value) override {
         if (key == "amopfamily") {
@@ -1242,10 +1261,12 @@ private:
     bool IsSupported_ = true;
 };
 
-
-class TAmsParser : public TParser {
+class TAmsParser: public TParser {
 public:
-    TAmsParser(TAms& ams) : Ams_(ams) {}
+    TAmsParser(TAms& ams)
+        : Ams_(ams)
+    {
+    }
 
     void OnKey(const TString& key, const TString& value) override {
         if (key == "oid") {
@@ -1276,17 +1297,18 @@ private:
     TAms& Ams_;
 };
 
-class TAmProcsParser : public TParser {
+class TAmProcsParser: public TParser {
 public:
     TAmProcsParser(TAmProcs& amProcs, const THashMap<TString, ui32>& typeByName,
-        const THashMap<TString, TVector<ui32>>& procByName, const TProcs& procs,
-        const TOpFamilies& opFamilies)
+                   const THashMap<TString, TVector<ui32>>& procByName, const TProcs& procs,
+                   const TOpFamilies& opFamilies)
         : AmProcs_(amProcs)
         , TypeByName_(typeByName)
         , ProcByName_(procByName)
         , Procs_(procs)
         , OpFamilies_(opFamilies)
-    {}
+    {
+    }
 
     void OnKey(const TString& key, const TString& value) override {
         if (key == "amprocfamily") {
@@ -1348,12 +1370,13 @@ private:
     bool IsSupported_ = true;
 };
 
-class TConversionsParser : public TParser {
+class TConversionsParser: public TParser {
 public:
     TConversionsParser(TConversions& conversions, const THashMap<TString, TVector<ui32>>& procByName)
         : Conversions_(conversions)
         , ProcByName_(procByName)
-    {}
+    {
+    }
 
     void OnKey(const TString& key, const TString& value) override {
         if (key == "oid") {
@@ -1390,11 +1413,12 @@ private:
     TConversionDesc LastConversion_;
 };
 
-class TLanguagesParser : public TParser {
+class TLanguagesParser: public TParser {
 public:
     TLanguagesParser(TLanguages& languages)
         : Languages_(languages)
-    {}
+    {
+    }
 
     void OnKey(const TString& key, const TString& value) override {
         if (key == "oid") {
@@ -1418,7 +1442,7 @@ private:
 };
 
 TOperators ParseOperators(const TString& dat, const THashMap<TString, ui32>& typeByName,
-    const TTypes& types, const THashMap<TString, TVector<ui32>>& procByName, const TProcs& procs, THashMap<ui32, TLazyOperInfo>& lazyInfos) {
+                          const TTypes& types, const THashMap<TString, TVector<ui32>>& procByName, const TProcs& procs, THashMap<ui32, TLazyOperInfo>& lazyInfos) {
     TOperators ret;
     TOperatorsParser parser(ret, typeByName, types, procByName, procs, lazyInfos);
     parser.Do(dat);
@@ -1480,7 +1504,7 @@ void ApplyLazyOperInfos(TOperators& operators, const THashMap<TString, TVector<u
 }
 
 TAggregations ParseAggregations(const TString& dat, const THashMap<TString, ui32>& typeByName,
-    const TTypes& types, const THashMap<TString, TVector<ui32>>& procByName, const TProcs& procs) {
+                                const TTypes& types, const THashMap<TString, TVector<ui32>>& procByName, const TProcs& procs) {
     TAggregations ret;
     TAggregationsParser parser(ret, typeByName, types, procByName, procs);
     parser.Do(dat);
@@ -1502,7 +1526,7 @@ TTypes ParseTypes(const TString& dat, THashMap<ui32, TLazyTypeInfo>& lazyInfos)
 }
 
 TCasts ParseCasts(const TString& dat, const THashMap<TString, ui32>& typeByName, const TTypes& types,
-    const THashMap<TString, TVector<ui32>>& procByName, const TProcs& procs) {
+                  const THashMap<TString, TVector<ui32>>& procByName, const TProcs& procs) {
     TCasts ret;
     TCastsParser parser(ret, typeByName, types, procByName, procs);
     parser.Do(dat);
@@ -1517,7 +1541,7 @@ TOpFamilies ParseOpFamilies(const TString& dat) {
 }
 
 TOpClasses ParseOpClasses(const TString& dat, const THashMap<TString, ui32>& typeByName,
-    const TOpFamilies& opFamilies) {
+                          const TOpFamilies& opFamilies) {
     TOpClasses ret;
     TOpClassesParser parser(ret, typeByName, opFamilies);
     parser.Do(dat);
@@ -1525,8 +1549,8 @@ TOpClasses ParseOpClasses(const TString& dat, const THashMap<TString, ui32>& typ
 }
 
 TAmOps ParseAmOps(const TString& dat, const THashMap<TString, ui32>& typeByName, const TTypes& types,
-    const THashMap<TString, TVector<ui32>>& operatorsByName, const TOperators& operators,
-    const TOpFamilies& opFamilies) {
+                  const THashMap<TString, TVector<ui32>>& operatorsByName, const TOperators& operators,
+                  const TOpFamilies& opFamilies) {
     TAmOps ret;
     TAmOpsParser parser(ret, typeByName, types, operatorsByName, operators, opFamilies);
     parser.Do(dat);
@@ -1534,8 +1558,8 @@ TAmOps ParseAmOps(const TString& dat, const THashMap<TString, ui32>& typeByName,
 }
 
 TAmProcs ParseAmProcs(const TString& dat, const THashMap<TString, ui32>& typeByName,
-    const THashMap<TString, TVector<ui32>>& procByName, const TProcs& procs,
-    const TOpFamilies& opFamilies) {
+                      const THashMap<TString, TVector<ui32>>& procByName, const TProcs& procs,
+                      const TOpFamilies& opFamilies) {
     TAmProcs ret;
     TAmProcsParser parser(ret, typeByName, procByName, procs, opFamilies);
     parser.Do(dat);
@@ -1579,7 +1603,7 @@ struct TTableInfoKeyRaw {
     const char* Name;
 };
 
-struct TTableInfoRaw : public TTableInfoKeyRaw {
+struct TTableInfoRaw: public TTableInfoKeyRaw {
     ERelKind Kind;
     ui32 Oid;
 };
@@ -1605,7 +1629,7 @@ const char* AllowedProcsRaw[] = {
 #include "postgis_procs.h"
 };
 
-struct TCatalog : public IExtensionSqlBuilder {
+struct TCatalog: public IExtensionSqlBuilder {
     TCatalog() {
         Init();
     }
@@ -1620,69 +1644,52 @@ struct TCatalog : public IExtensionSqlBuilder {
         for (size_t i = 0; i < Y_ARRAY_SIZE(AllStaticTablesRaw); ++i) {
             const auto& raw = AllStaticTablesRaw[i];
             State->AllStaticTables.push_back(
-                {{TString(raw.Schema), TString(raw.Name)}, raw.Kind, raw.Oid}
-            );
+                {{TString(raw.Schema), TString(raw.Name)}, raw.Kind, raw.Oid});
         }
 
         for (size_t i = 0; i < Y_ARRAY_SIZE(AllStaticColumnsRaw); ++i) {
             const auto& raw = AllStaticColumnsRaw[i];
             State->AllStaticColumns.push_back(
-                {TString(raw.Schema), TString(raw.TableName), TString(raw.Name), TString(raw.UdtType)}
-            );
+                {TString(raw.Schema), TString(raw.TableName), TString(raw.Name), TString(raw.UdtType)});
         }
 
-        if ( GetEnv("YDB_EXPERIMENTAL_PG") == "1"){
+        if (GetEnv("YDB_EXPERIMENTAL_PG") == "1") {
             // grafana migration_log
             State->AllStaticTables.push_back(
-                {{"public", "migration_log"}, ERelKind::Relation, 100001}
-            );
+                {{"public", "migration_log"}, ERelKind::Relation, 100001});
             State->AllStaticColumns.push_back(
-                {"public", "migration_log", "id", "int"}
-            );
+                {"public", "migration_log", "id", "int"});
             State->AllStaticColumns.push_back(
-                {"public", "migration_log", "migration_id", "character varying(255)"}
-            );
+                {"public", "migration_log", "migration_id", "character varying(255)"});
             State->AllStaticColumns.push_back(
-                {"public", "migration_log", "sql", "text"}
-            );
+                {"public", "migration_log", "sql", "text"});
             State->AllStaticColumns.push_back(
-                {"public", "migration_log", "success", "boolean"}
-            );
+                {"public", "migration_log", "success", "boolean"});
             State->AllStaticColumns.push_back(
-                {"public", "migration_log", "error", "text"}
-            );
+                {"public", "migration_log", "error", "text"});
             State->AllStaticColumns.push_back(
-                {"public", "migration_log", "timestamp", "timestamp without time zone"}
-            );
+                {"public", "migration_log", "timestamp", "timestamp without time zone"});
 
             // zabbix config
             State->AllStaticTables.push_back(
-                {{"public", "config"}, ERelKind::Relation, 100001}
-            );
+                {{"public", "config"}, ERelKind::Relation, 100001});
             State->AllStaticColumns.push_back(
-                {"public", "config", "configid", "bigint"}
-            );
+                {"public", "config", "configid", "bigint"});
             State->AllStaticColumns.push_back(
-                {"public", "config", "server_check_interval", "integer"}
-            );
+                {"public", "config", "server_check_interval", "integer"});
 
             State->AllStaticColumns.push_back(
-                {"public", "config", "dbversion_status", "text"}
-            );
+                {"public", "config", "dbversion_status", "text"});
 
             // zabbix dbversion
             State->AllStaticTables.push_back(
-                {{"public", "dbversion"}, ERelKind::Relation, 100002}
-            );
+                {{"public", "dbversion"}, ERelKind::Relation, 100002});
             State->AllStaticColumns.push_back(
-                {"public", "dbversion", "dbversionid", "bigint"}
-            );
+                {"public", "dbversion", "dbversionid", "bigint"});
             State->AllStaticColumns.push_back(
-                {"public", "dbversion", "mandatory", "integer"}
-            );
+                {"public", "dbversion", "mandatory", "integer"});
             State->AllStaticColumns.push_back(
-                {"public", "dbversion", "mandatory", "optional"}
-            );
+                {"public", "dbversion", "mandatory", "optional"});
         }
         THashSet<ui32> usedTableOids;
         for (const auto& t : State->AllStaticTables) {
@@ -1691,7 +1698,7 @@ struct TCatalog : public IExtensionSqlBuilder {
             State->StaticTables.insert(std::make_pair(TTableInfoKey(t), t));
         }
 
-        for (const auto& c: State->AllStaticColumns) {
+        for (const auto& c : State->AllStaticColumns) {
             auto tablePtr = State->StaticColumns.FindPtr(TTableInfoKey{c.Schema, c.TableName});
             Y_ENSURE(tablePtr);
             tablePtr->push_back(c);
@@ -1829,19 +1836,19 @@ struct TCatalog : public IExtensionSqlBuilder {
         }
 
         State->Casts = ParseCasts(castData, State->TypeByName, State->Types, State->ProcByName, State->Procs);
-        for (const auto&[k, v] : State->Casts) {
+        for (const auto& [k, v] : State->Casts) {
             Y_ENSURE(State->CastsByDir.insert(std::make_pair(std::make_pair(v.SourceId, v.TargetId), k)).second);
         }
 
         THashMap<ui32, TLazyOperInfo> lazyOperInfos;
         State->Operators = ParseOperators(opData, State->TypeByName, State->Types, State->ProcByName, State->Procs, lazyOperInfos);
-        for (const auto&[k, v] : State->Operators) {
+        for (const auto& [k, v] : State->Operators) {
             State->OperatorsByName[v.Name].push_back(k);
         }
 
         ApplyLazyOperInfos(State->Operators, State->OperatorsByName, State->TypeByName, lazyOperInfos);
         State->Aggregations = ParseAggregations(aggData, State->TypeByName, State->Types, State->ProcByName, State->Procs);
-        for (const auto&[k, v] : State->Aggregations) {
+        for (const auto& [k, v] : State->Aggregations) {
             State->AggregationsByName[v.Name].push_back(k);
         }
 
@@ -1931,7 +1938,7 @@ struct TCatalog : public IExtensionSqlBuilder {
         }
 
         TString line = TStringBuilder() << "\"" << name << "\",\n";
-        with_lock(ExportGuard) {
+        with_lock (ExportGuard) {
             ExportFile->Write(line.data(), line.size());
         }
     }
@@ -2065,7 +2072,7 @@ struct TCatalog : public IExtensionSqlBuilder {
     }
 
     void InsertValues(const TTableInfoKey& table, const TVector<TString>& columns,
-        const TVector<TMaybe<TString>>& data) final {
+                      const TVector<TMaybe<TString>>& data) final {
         Y_ENSURE(State->StaticTables.contains(table));
         const auto& columnDefs = *State->StaticColumns.FindPtr(table);
         Y_ENSURE(columnDefs.size() == columns.size());
@@ -2304,8 +2311,7 @@ const TProcDesc& LookupProc(ui32 procId, const TVector<ui32>& argTypeIds) {
     }
 
     if (!ValidateProcArgs(*procPtr, argTypeIds)) {
-        throw yexception() << "Unable to find an overload for proc with oid " << procId << " with given argument types: " <<
-            ArgTypesList(argTypeIds);
+        throw yexception() << "Unable to find an overload for proc with oid " << procId << " with given argument types: " << ArgTypesList(argTypeIds);
     }
 
     catalog.ExportFunction(procId);
@@ -2336,7 +2342,7 @@ const TProcDesc& LookupProc(const TString& name, const TVector<ui32>& argTypeIds
     }
 
     throw yexception() << "Unable to find an overload for proc " << name << " with given argument types: "
-        << ArgTypesList(argTypeIds);
+                       << ArgTypesList(argTypeIds);
 }
 
 const TProcDesc& LookupProc(ui32 procId) {
@@ -2486,7 +2492,6 @@ void EnumOperators(std::function<void(const TOperDesc&)> f) {
     }
 }
 
-
 bool HasCast(ui32 sourceId, ui32 targetId) {
     const auto& catalog = TCatalog::Instance();
     return catalog.State->CastsByDir.contains(std::make_pair(sourceId, targetId));
@@ -2511,21 +2516,20 @@ constexpr ui64 NoFitScore = 0;
 bool CanUseCoercionType(ECoercionCode requiredCoercionLevel, ECoercionCode actualCoercionLevel) {
     switch (requiredCoercionLevel) {
         case NYql::NPg::ECoercionCode::Implicit:
-           return actualCoercionLevel == ECoercionCode::Implicit;
+            return actualCoercionLevel == ECoercionCode::Implicit;
 
         case NYql::NPg::ECoercionCode::Assignment:
-           return (actualCoercionLevel == ECoercionCode::Implicit) || (actualCoercionLevel == ECoercionCode::Assignment);
+            return (actualCoercionLevel == ECoercionCode::Implicit) || (actualCoercionLevel == ECoercionCode::Assignment);
 
         case NYql::NPg::ECoercionCode::Explicit:
-           return (actualCoercionLevel != ECoercionCode::Unknown);
+            return (actualCoercionLevel != ECoercionCode::Unknown);
 
         case NYql::NPg::ECoercionCode::Unknown:
             return false;
     }
 }
 
-enum class ECoercionSearchResult
-{
+enum class ECoercionSearchResult {
     None,
     Func,
     BinaryCompatible,
@@ -2600,13 +2604,13 @@ bool IsCoercible(ui32 fromTypeId, ui32 toTypeId, ECoercionCode coercionType, con
     if (toTypeId == AnyOid) {
         return true;
     }
-    //TODO: support polymorphic types
+    // TODO: support polymorphic types
 
     if (fromTypeId == UnknownOid) {
         return true;
     }
 
-    if (FindCoercionPath(fromTypeId, toTypeId, coercionType, catalog) != ECoercionSearchResult::None ) {
+    if (FindCoercionPath(fromTypeId, toTypeId, coercionType, catalog) != ECoercionSearchResult::None) {
         return true;
     }
 
@@ -2638,7 +2642,7 @@ bool IsPreferredType(char categoryId, const TTypeDesc& type) {
 }
 
 constexpr ui32 CoercibleMatchShift = 16;
-constexpr ui64 ArgExactTypeMatch = 1ULL << 2*CoercibleMatchShift;
+constexpr ui64 ArgExactTypeMatch = 1ULL << 2 * CoercibleMatchShift;
 constexpr ui64 ArgPreferredTypeMatch = 1ULL << CoercibleMatchShift;
 constexpr ui64 ArgCoercibleTypeMatch = 1ULL;
 constexpr ui64 ArgTypeMismatch = 0;
@@ -2676,8 +2680,7 @@ ui64 CalcBinaryOperatorScore(const TOperDesc& oper, ui32 leftArgTypeId, ui32 rig
         if (oper.LeftType == rightArgTypeId && oper.RightType == rightArgTypeId) {
             return ArgExactTypeMatch + ArgExactTypeMatch;
         }
-    }
-    else if (rightArgTypeId == UnknownOid && leftArgTypeId != InvalidOid) {
+    } else if (rightArgTypeId == UnknownOid && leftArgTypeId != InvalidOid) {
         if (oper.LeftType == leftArgTypeId && oper.RightType == leftArgTypeId) {
             return ArgExactTypeMatch + ArgExactTypeMatch;
         }
@@ -2760,32 +2763,32 @@ ui64 CalcProcScore(const TVector<ui32>& procArgTypes, ui32 procVariadicType, ui3
 
 [[noreturn]] void ThrowOperatorNotFound(const TString& name, const TVector<ui32>& argTypeIds) {
     throw yexception() << "Unable to find an overload for operator " << name << " with given argument type(s): "
-        << ArgTypesList(argTypeIds);
+                       << ArgTypesList(argTypeIds);
 }
 
 [[noreturn]] void ThrowOperatorAmbiguity(const TString& name, const TVector<ui32>& argTypeIds) {
     throw yexception() << "Ambiguity for operator " << name << " with given argument type(s): "
-        << ArgTypesList(argTypeIds);
+                       << ArgTypesList(argTypeIds);
 }
 
 [[noreturn]] void ThrowProcNotFound(const TString& name, const TVector<ui32>& argTypeIds) {
     throw yexception() << "Unable to find an overload for proc " << name << " with given argument types: "
-        << ArgTypesList(argTypeIds);
+                       << ArgTypesList(argTypeIds);
 }
 
 [[noreturn]] void ThrowProcAmbiguity(const TString& name, const TVector<ui32>& argTypeIds) {
     throw yexception() << "Ambiguity for proc " << name << " with given argument type(s): "
-        << ArgTypesList(argTypeIds);
+                       << ArgTypesList(argTypeIds);
 }
 
 [[noreturn]] void ThrowAggregateNotFound(const TString& name, const TVector<ui32>& argTypeIds) {
     throw yexception() << "Unable to find an overload for aggregate " << name << " with given argument types: "
-        << ArgTypesList(argTypeIds);
+                       << ArgTypesList(argTypeIds);
 }
 
 [[noreturn]] void ThrowAggregateAmbiguity(const TString& name, const TVector<ui32>& argTypeIds) {
     throw yexception() << "Ambiguity for aggregate " << name << " with given argument type(s): "
-        << ArgTypesList(argTypeIds);
+                       << ArgTypesList(argTypeIds);
 }
 
 struct TCommonCategoryDesc {
@@ -2794,11 +2797,15 @@ struct TCommonCategoryDesc {
     bool IsPreferred = false;
 
     TCommonCategoryDesc(size_t position, char category, bool isPreferred)
-    : Position(position), Category(category), IsPreferred(isPreferred) {}
+        : Position(position)
+        , Category(category)
+        , IsPreferred(isPreferred)
+    {
+    }
 };
 
 template <class C>
-char FindCommonCategory(const TVector<const C*> &candidates, std::function<ui32(const C*)> getTypeId, const TCatalog &catalog, bool &isPreferred) {
+char FindCommonCategory(const TVector<const C*>& candidates, std::function<ui32(const C*)> getTypeId, const TCatalog& catalog, bool& isPreferred) {
     char category = InvalidCategory;
     auto isConflict = false;
     isPreferred = false;
@@ -2844,7 +2851,7 @@ TVector<const C*> TryResolveUnknownsByCategory(const TVector<const C*>& candidat
         char category = InvalidCategory;
         bool isPreferred = false;
 
-        std::function<ui32(const C *)> typeGetter = [i] (const auto* candidate) {
+        std::function<ui32(const C*)> typeGetter = [i](const auto* candidate) {
             if constexpr (std::is_same_v<C, TProcDesc>) {
                 return i < candidate->ArgTypes.size() ? candidate->ArgTypes[i] : candidate->VariadicType;
             } else {
@@ -2908,16 +2915,16 @@ TVector<const TOperDesc*> TryResolveUnknownsByCategory<TOperDesc>(const TVector<
         char category = InvalidCategory;
         bool isPreferred = false;
 
-        std::function <ui32(const TOperDesc*)> typeGetter;
+        std::function<ui32(const TOperDesc*)> typeGetter;
         if (i == 1) {
-            typeGetter = [] (const auto* candidate) {
+            typeGetter = [](const auto* candidate) {
                 return candidate->RightType;
             };
         } else {
-            typeGetter = [] (const auto* candidate) {
+            typeGetter = [](const auto* candidate) {
                 return (candidate->Kind == EOperKind::Binary)
-                    ? candidate->LeftType
-                    : candidate->RightType;
+                           ? candidate->LeftType
+                           : candidate->RightType;
             };
         }
 
@@ -2936,8 +2943,9 @@ TVector<const TOperDesc*> TryResolveUnknownsByCategory<TOperDesc>(const TVector<
 
         for (const auto& category : argCommonCategory) {
             const auto argTypeId = (category.Position == 1)
-                ? candidate->RightType
-                : (candidate->Kind == EOperKind::Binary) ? candidate->LeftType : candidate->RightType;
+                                       ? candidate->RightType
+                                   : (candidate->Kind == EOperKind::Binary) ? candidate->LeftType
+                                                                            : candidate->RightType;
 
             const auto& argTypePtr = catalog.State->Types.FindPtr(argTypeId);
             Y_ENSURE(argTypePtr);
@@ -2970,7 +2978,7 @@ bool CanCastImplicitly(ui32 fromTypeId, ui32 toTypeId, const TCatalog& catalog)
     return (castPtr->CoercionCode == ECoercionCode::Implicit);
 }
 
-}  // NPrivate
+} // namespace NPrivate
 
 bool IsCoercible(ui32 fromTypeId, ui32 toTypeId, ECoercionCode coercionType) {
     const auto& catalog = TCatalog::Instance();
@@ -3032,7 +3040,7 @@ std::variant<const TProcDesc*, const TTypeDesc*> LookupProcWithCasts(const TStri
             }
 
             const auto coercionType = NPrivate::FindCoercionPath(fromTypeId, typePtr->TypeId,
-                ECoercionCode::Explicit, catalog);
+                                                                 ECoercionCode::Explicit, catalog);
 
             switch (coercionType) {
                 case NPrivate::ECoercionSearchResult::BinaryCompatible:
@@ -3077,7 +3085,7 @@ std::variant<const TProcDesc*, const TTypeDesc*> LookupProcWithCasts(const TStri
     if (unknownsCount < argTypeIds.size()) {
         ui32 commonType = UnknownOid;
 
-        for (const auto argType: argTypeIds) {
+        for (const auto argType : argTypeIds) {
             if (argType == UnknownOid) {
                 continue;
             }
@@ -3147,7 +3155,7 @@ TMaybe<TIssue> LookupCommonType(const TVector<ui32>& typeIds, const std::functio
         if (otherType.Category != commonCategory) {
             // https://www.postgresql.org/docs/14/typeconv-union-case.html, step 4
             return TIssue(GetPosition(i), TStringBuilder() << "Cannot infer common type for types "
-                << commonType->TypeId << " and " << otherType.TypeId);
+                                                           << commonType->TypeId << " and " << otherType.TypeId);
         }
         castsNeeded = true;
         if (NPrivate::CanCastImplicitly(otherType.TypeId, commonType->TypeId, catalog)) {
@@ -3155,7 +3163,7 @@ TMaybe<TIssue> LookupCommonType(const TVector<ui32>& typeIds, const std::functio
         }
         if (commonType->IsPreferred || !NPrivate::CanCastImplicitly(commonType->TypeId, otherType.TypeId, catalog)) {
             return TIssue(GetPosition(i), TStringBuilder() << "Cannot infer common type for types "
-                << commonType->TypeId << " and " << otherType.TypeId);
+                                                           << commonType->TypeId << " and " << otherType.TypeId);
         }
         commonType = &otherType;
     }
@@ -3170,12 +3178,11 @@ TMaybe<TIssue> LookupCommonType(const TVector<ui32>& typeIds, const std::functio
     return {};
 }
 
-TMaybe<TIssue> LookupCommonType(const TVector<ui32>& typeIds, const std::function<TPosition(size_t i)>&GetPosition, const TTypeDesc*& typeDesc) {
+TMaybe<TIssue> LookupCommonType(const TVector<ui32>& typeIds, const std::function<TPosition(size_t i)>& GetPosition, const TTypeDesc*& typeDesc) {
     bool _;
     return LookupCommonType(typeIds, GetPosition, typeDesc, _);
 }
 
-
 const TOperDesc& LookupOper(const TString& name, const TVector<ui32>& argTypeIds) {
     const auto& catalog = TCatalog::Instance();
 
@@ -3190,16 +3197,16 @@ const TOperDesc& LookupOper(const TString& name, const TVector<ui32>& argTypeIds
     switch (argTypeIds.size()) {
         case 2:
             expectedOpKind = EOperKind::Binary;
-            calcScore = [&] (const auto* d) {
-                 return NPrivate::CalcBinaryOperatorScore(*d, argTypeIds[0], argTypeIds[1], catalog);
-                 };
+            calcScore = [&](const auto* d) {
+                return NPrivate::CalcBinaryOperatorScore(*d, argTypeIds[0], argTypeIds[1], catalog);
+            };
             break;
 
         case 1:
             expectedOpKind = EOperKind::LeftUnary;
-            calcScore = [&] (const auto* d) {
+            calcScore = [&](const auto* d) {
                 return NPrivate::CalcUnaryOperatorScore(*d, argTypeIds[0], catalog);
-                };
+            };
             break;
 
         default:
@@ -3263,7 +3270,7 @@ const TOperDesc& LookupOper(const TString& name, const TVector<ui32>& argTypeIds
         NPrivate::ThrowOperatorNotFound(name, argTypeIds);
     }
 
-    auto TryResolveUnknownsBySpreadingType = [&] (ui32 argTypeId, std::function<ui32(const TOperDesc*)> getArgType) {
+    auto TryResolveUnknownsBySpreadingType = [&](ui32 argTypeId, std::function<ui32(const TOperDesc*)> getArgType) {
         const TOperDesc* finalCandidate = nullptr;
 
         for (const auto* candidate : candidates) {
@@ -3279,9 +3286,9 @@ const TOperDesc& LookupOper(const TString& name, const TVector<ui32>& argTypeIds
 
     const TOperDesc* finalCandidate = nullptr;
     if (argTypeIds[0] == UnknownOid) {
-        finalCandidate = TryResolveUnknownsBySpreadingType(argTypeIds[1], [&] (const auto* oper) { return oper->LeftType; });
+        finalCandidate = TryResolveUnknownsBySpreadingType(argTypeIds[1], [&](const auto* oper) { return oper->LeftType; });
     } else if (argTypeIds[1] == UnknownOid) {
-        finalCandidate = TryResolveUnknownsBySpreadingType(argTypeIds[0], [&] (const auto* oper) { return oper->RightType; });
+        finalCandidate = TryResolveUnknownsBySpreadingType(argTypeIds[0], [&](const auto* oper) { return oper->RightType; });
     }
 
     if (finalCandidate) {
@@ -3299,7 +3306,7 @@ const TOperDesc& LookupOper(ui32 operId, const TVector<ui32>& argTypeIds) {
 
     if (!ValidateOperArgs(*operPtr, argTypeIds, catalog.State->Types)) {
         throw yexception() << "Unable to find an overload for operator with oid " << operId << " with given argument types: "
-            << ArgTypesList(argTypeIds);
+                           << ArgTypesList(argTypeIds);
     }
 
     return *operPtr;
@@ -3412,7 +3419,7 @@ const TAggregateDesc& LookupAggregation(const TString& name, const TVector<ui32>
     if (unknownsCount < argTypeIds.size()) {
         ui32 commonType = UnknownOid;
 
-        for (const auto argType: argTypeIds) {
+        for (const auto argType : argTypeIds) {
             if (argType == UnknownOid) {
                 continue;
             }
@@ -3477,9 +3484,7 @@ const TAggregateDesc& LookupAggregation(const TString& name, ui32 stateType, ui3
         return *d;
     }
 
-    throw yexception() << "Unable to find an overload for aggregate " << name << " with given state type: " <<
-        NPg::LookupType(stateType).Name << " and result type: " <<
-        NPg::LookupType(resultType).Name;
+    throw yexception() << "Unable to find an overload for aggregate " << name << " with given state type: " << NPg::LookupType(stateType).Name << " and result type: " << NPg::LookupType(resultType).Name;
 }
 
 void EnumAggregation(std::function<void(ui32, const TAggregateDesc&)> f) {
@@ -3498,8 +3503,9 @@ const TOpClassDesc* LookupDefaultOpClass(EOpClassMethod method, ui32 typeId) {
     const auto& catalog = TCatalog::Instance();
     auto lookupId = (typeId == VarcharOid ? TextOid : typeId);
     const auto opClassPtr = catalog.State->OpClasses.FindPtr(std::make_pair(method, lookupId));
-    if (opClassPtr)
+    if (opClassPtr) {
         return opClassPtr;
+    }
 
     throw yexception() << "No such opclass";
 
@@ -3507,7 +3513,7 @@ const TOpClassDesc* LookupDefaultOpClass(EOpClassMethod method, ui32 typeId) {
 }
 
 bool HasAmOp(ui32 familyId, ui32 strategy, ui32 leftType, ui32 rightType) {
-    const auto &catalog = TCatalog::Instance();
+    const auto& catalog = TCatalog::Instance();
     return catalog.State->AmOps.contains(std::make_tuple(familyId, strategy, leftType, rightType));
 }
 
@@ -3522,7 +3528,7 @@ const TAmOpDesc& LookupAmOp(ui32 familyId, ui32 strategy, ui32 leftType, ui32 ri
 }
 
 bool HasAmProc(ui32 familyId, ui32 num, ui32 leftType, ui32 rightType) {
-    const auto &catalog = TCatalog::Instance();
+    const auto& catalog = TCatalog::Instance();
     return catalog.State->AmProcs.contains(std::make_tuple(familyId, num, leftType, rightType));
 }
 
@@ -3537,7 +3543,7 @@ const TAmProcDesc& LookupAmProc(ui32 familyId, ui32 num, ui32 leftType, ui32 rig
 }
 
 bool HasConversion(const TString& from, const TString& to) {
-    const auto &catalog = TCatalog::Instance();
+    const auto& catalog = TCatalog::Instance();
     return catalog.State->Conversions.contains(std::make_pair(from, to));
 }
 
@@ -3602,13 +3608,13 @@ const TVector<TMaybe<TString>>* ReadTable(
     auto dataPtr = catalog.State->StaticTablesData.FindPtr(tableKey);
     if (!dataPtr) {
         throw yexception() << "Missing data for table "
-            << tableKey.Schema << "." << tableKey.Name;
+                           << tableKey.Schema << "." << tableKey.Name;
     }
 
     const auto& allColumns = *catalog.State->StaticColumns.FindPtr(tableKey);
     THashMap<TString, size_t> columnsToIndex;
     for (size_t i = 0; i < allColumns.size(); ++i) {
-        Y_ENSURE(columnsToIndex.emplace(allColumns[i].Name,i).second);
+        Y_ENSURE(columnsToIndex.emplace(allColumns[i].Name, i).second);
     }
 
     rowStep = allColumns.size();
@@ -3616,7 +3622,7 @@ const TVector<TMaybe<TString>>* ReadTable(
         auto indexPtr = columnsToIndex.FindPtr(columnNames[i]);
         if (!indexPtr) {
             throw yexception() << "Missing column " << columnNames[i] << " in table "
-                << tableKey.Schema << "." << tableKey.Name;
+                               << tableKey.Schema << "." << tableKey.Name;
         }
 
         columnsRemap[i] = *indexPtr;
@@ -3685,7 +3691,7 @@ void LoadSystemFunctions(ISystemFunctionsParser& parser) {
 }
 
 void RegisterExtensions(const TVector<TExtensionDesc>& extensions, bool typesOnly,
-    IExtensionSqlParser& parser, IExtensionLoader* loader) {
+                        IExtensionSqlParser& parser, IExtensionLoader* loader) {
     YQL_PROFILE_FUNC(DEBUG);
     if (extensions.size() > MaximumExtensionsCount) {
         throw yexception() << "Too many extensions: " << extensions.size();
@@ -4354,4 +4360,4 @@ ui32 LookupExtensionByInstallName(const TString& installName) {
     return *indexPtr;
 }
 
-}
+} // namespace NYql::NPg
diff --git a/yql/essentials/parser/pg_catalog/catalog.h b/yql/essentials/parser/pg_catalog/catalog.h
index e753f2ebc82..09e080f7a10 100644
--- a/yql/essentials/parser/pg_catalog/catalog.h
+++ b/yql/essentials/parser/pg_catalog/catalog.h
@@ -13,7 +13,7 @@ struct Node;
 namespace NYql {
 class TExprNode;
 struct TExprContext;
-}
+} // namespace NYql
 
 namespace NYql::NPg {
 
@@ -27,8 +27,7 @@ constexpr ui32 VarcharOid = 1043;
 constexpr ui32 TextOid = 25;
 
 // copied from pg_class.h
-enum class ERelPersistence : char
-{
+enum class ERelPersistence: char {
     Permanent = 'p',
     Unlogged = 'u',
     Temp = 't',
@@ -54,7 +53,7 @@ struct TOperDesc {
     ui32 ExtensionIndex = 0;
 };
 
-enum class EProcKind : char {
+enum class EProcKind: char {
     Function = 'f',
     Aggregate = 'a',
     Window = 'w'
@@ -93,7 +92,7 @@ constexpr ui32 C_CollationOid = 950;
 constexpr ui32 PosixCollationOid = 951;
 
 // Copied from pg_type_d.h, TYPTYPE_* constants
-enum class ETypType : char {
+enum class ETypType: char {
     Base = 'b',
     Composite = 'c',
     Domain = 'd',
@@ -150,11 +149,11 @@ enum class ECastMethod {
     Binary
 };
 
-enum class ECoercionCode : char {
-    Unknown = '?',      // not specified
-    Implicit = 'i',     // coercion in context of expression
-    Assignment = 'a',   // coercion in context of assignment
-    Explicit = 'e',     // explicit cast operation
+enum class ECoercionCode: char {
+    Unknown = '?',    // not specified
+    Implicit = 'i',   // coercion in context of expression
+    Assignment = 'a', // coercion in context of assignment
+    Explicit = 'e',   // explicit cast operation
 };
 
 struct TCastDesc {
@@ -166,7 +165,7 @@ struct TCastDesc {
     ui32 ExtensionIndex = 0;
 };
 
-enum class EAggKind : char {
+enum class EAggKind: char {
     Normal = 'n',
     OrderedSet = 'o',
     Hypothetical = 'h'
@@ -337,7 +336,7 @@ inline bool IsArrayType(const TTypeDesc& typeDesc) noexcept {
     return typeDesc.ArrayTypeId == typeDesc.TypeId;
 }
 
-enum class ERelKind : char {
+enum class ERelKind: char {
     Relation = 'r',
     View = 'v'
 };
@@ -371,7 +370,7 @@ constexpr ui32 NamespaceRelationOid = 2615;
 constexpr ui32 AuthMemRelationOid = 1261;
 constexpr ui32 RelationRelationOid = 1259;
 
-struct TTableInfo : public TTableInfoKey {
+struct TTableInfo: public TTableInfoKey {
     ERelKind Kind;
     ui32 Oid;
     ui32 ExtensionIndex = 0;
@@ -398,13 +397,13 @@ bool AreAllFunctionsAllowed();
 void AllowFunction(const TString& name);
 
 struct TExtensionDesc {
-    TString Name;               // postgis
-    TString InstallName;        // $libdir/postgis-3
-    TVector<TString> SqlPaths;  // paths to SQL files with DDL (CREATE TYPE/CREATE FUNCTION/etc), DML (INSERT/VALUES)
-    TString LibraryPath;        // file path
-    bool TypesOnly = false;     // Can't be loaded if true
-    TString LibraryMD5;         // optional
-    TString Version;            // version of extension
+    TString Name;              // postgis
+    TString InstallName;       // $libdir/postgis-3
+    TVector<TString> SqlPaths; // paths to SQL files with DDL (CREATE TYPE/CREATE FUNCTION/etc), DML (INSERT/VALUES)
+    TString LibraryPath;       // file path
+    bool TypesOnly = false;    // Can't be loaded if true
+    TString LibraryMD5;        // optional
+    TString Version;           // version of extension
 };
 
 class IExtensionSqlBuilder {
@@ -413,14 +412,14 @@ public:
 
     virtual void CreateProc(const TProcDesc& desc) = 0;
 
-    virtual void PrepareType(ui32 extensionIndex,const TString& name) = 0;
+    virtual void PrepareType(ui32 extensionIndex, const TString& name) = 0;
 
     virtual void UpdateType(const TTypeDesc& desc) = 0;
 
     virtual void CreateTable(const TTableInfo& table, const TVector<TColumnInfo>& columns) = 0;
 
     virtual void InsertValues(const TTableInfoKey& table, const TVector<TString>& columns,
-        const TVector<TMaybe<TString>>& data) = 0; // row based layout
+                              const TVector<TMaybe<TString>>& data) = 0; // row based layout
 
     virtual void CreateCast(const TCastDesc& desc) = 0;
 
@@ -467,7 +466,7 @@ void LoadSystemFunctions(ISystemFunctionsParser& parser);
 
 // either RegisterExtensions or ImportExtensions should be called at most once, see ClearExtensions as well
 void RegisterExtensions(const TVector<TExtensionDesc>& extensions, bool typesOnly,
-    IExtensionSqlParser& parser, IExtensionLoader* loader);
+                        IExtensionSqlParser& parser, IExtensionLoader* loader);
 // converts all library paths to basenames
 TString ExportExtensions(const TMaybe<TSet<ui32>>& filter = Nothing());
 void ImportExtensions(const TString& exported, bool typesOnly, IExtensionLoader* loader);
@@ -478,7 +477,7 @@ const TExtensionDesc& LookupExtension(ui32 extensionIndex);
 ui32 LookupExtensionByName(const TString& name);
 ui32 LookupExtensionByInstallName(const TString& installName);
 
-}
+} // namespace NYql::NPg
 
 template <>
 inline void Out<NYql::NPg::ETypType>(IOutputStream& o, NYql::NPg::ETypType typType) {
@@ -492,7 +491,7 @@ inline void Out<NYql::NPg::ECoercionCode>(IOutputStream& o, NYql::NPg::ECoercion
 
 template <>
 struct THash<NYql::NPg::TTableInfoKey> {
-    size_t operator ()(const NYql::NPg::TTableInfoKey& val) const {
+    size_t operator()(const NYql::NPg::TTableInfoKey& val) const {
         return val.Hash();
     }
 };
diff --git a/yql/essentials/parser/pg_catalog/generate_system_columns.py b/yql/essentials/parser/pg_catalog/generate_system_columns.py
index 14764c3e1f0..063a3f21f34 100755
--- a/yql/essentials/parser/pg_catalog/generate_system_columns.py
+++ b/yql/essentials/parser/pg_catalog/generate_system_columns.py
@@ -3,26 +3,37 @@
 with open("pg_class.txt") as f:
     pg_class_file = f.readlines()
 
-with open("pg_class.generated.h","w") as f:
+with open("pg_class.generated.h", "w") as f:
     for p in pg_class_file[2:-2]:
-        s=p.split("|")
-        oid=int(s[0].strip())
-        relkind=s[1].strip()
-        relname=s[2].strip()
-        nspname=s[3].strip()
-        print(oid,relkind,relname,nspname)
-        print('{{"' + nspname + '", "' + relname + '"}, ERelKind::' + ("Relation" if relkind == 'r' else "View") +", " + str(oid) + "},", file=f)
+        s = p.split("|")
+        oid = int(s[0].strip())
+        relkind = s[1].strip()
+        relname = s[2].strip()
+        nspname = s[3].strip()
+        print(oid, relkind, relname, nspname)
+        print(
+            '{{"'
+            + nspname
+            + '", "'
+            + relname
+            + '"}, ERelKind::'
+            + ("Relation" if relkind == 'r' else "View")
+            + ", "
+            + str(oid)
+            + "},",
+            file=f,
+        )
 
 with open("columns.txt") as f:
     columns_file = f.readlines()
 
-with open("columns.generated.h","w") as f:
+with open("columns.generated.h", "w") as f:
     for p in columns_file[2:-2]:
-        s=p.split("|")
+        s = p.split("|")
         print(s)
-        name=s[0].strip()
-        relname=s[1].strip()
-        schemaname=s[2].strip()
-        udt=s[3].strip()
-        print(schemaname,relname,name,udt)
+        name = s[0].strip()
+        relname = s[1].strip()
+        schemaname = s[2].strip()
+        udt = s[3].strip()
+        print(schemaname, relname, name, udt)
         print('{"' + schemaname + '", "' + relname + '", "' + name + '", "' + udt + '"},', file=f)
diff --git a/yql/essentials/parser/pg_catalog/ut/catalog_consts_ut.cpp b/yql/essentials/parser/pg_catalog/ut/catalog_consts_ut.cpp
index 04ec9ee3083..10286c5d5b5 100644
--- a/yql/essentials/parser/pg_catalog/ut/catalog_consts_ut.cpp
+++ b/yql/essentials/parser/pg_catalog/ut/catalog_consts_ut.cpp
@@ -19,53 +19,52 @@ extern "C" {
 
 #include <library/cpp/testing/unittest/registar.h>
 
-
 using namespace NYql::NPg;
 
 Y_UNIT_TEST_SUITE(TConstantsTests) {
-    Y_UNIT_TEST(TestCollationConsts) {
-        UNIT_ASSERT(NYql::NPg::DefaultCollationOid == DEFAULT_COLLATION_OID);
-        UNIT_ASSERT(NYql::NPg::C_CollationOid == C_COLLATION_OID);
-        UNIT_ASSERT(NYql::NPg::PosixCollationOid == POSIX_COLLATION_OID);
-    }
+Y_UNIT_TEST(TestCollationConsts) {
+    UNIT_ASSERT(NYql::NPg::DefaultCollationOid == DEFAULT_COLLATION_OID);
+    UNIT_ASSERT(NYql::NPg::C_CollationOid == C_COLLATION_OID);
+    UNIT_ASSERT(NYql::NPg::PosixCollationOid == POSIX_COLLATION_OID);
+}
 
-    Y_UNIT_TEST(BTreeAmStrategyConsts) {
-        UNIT_ASSERT(static_cast<ui32>(NYql::NPg::EBtreeAmStrategy::Less) == BTLessStrategyNumber);
-        UNIT_ASSERT(static_cast<ui32>(NYql::NPg::EBtreeAmStrategy::LessOrEqual) == BTLessEqualStrategyNumber);
-        UNIT_ASSERT(static_cast<ui32>(NYql::NPg::EBtreeAmStrategy::Equal) == BTEqualStrategyNumber);
-        UNIT_ASSERT(static_cast<ui32>(NYql::NPg::EBtreeAmStrategy::GreaterOrEqual) == BTGreaterEqualStrategyNumber);
-        UNIT_ASSERT(static_cast<ui32>(NYql::NPg::EBtreeAmStrategy::Greater) == BTGreaterStrategyNumber);
-    }
+Y_UNIT_TEST(BTreeAmStrategyConsts) {
+    UNIT_ASSERT(static_cast<ui32>(NYql::NPg::EBtreeAmStrategy::Less) == BTLessStrategyNumber);
+    UNIT_ASSERT(static_cast<ui32>(NYql::NPg::EBtreeAmStrategy::LessOrEqual) == BTLessEqualStrategyNumber);
+    UNIT_ASSERT(static_cast<ui32>(NYql::NPg::EBtreeAmStrategy::Equal) == BTEqualStrategyNumber);
+    UNIT_ASSERT(static_cast<ui32>(NYql::NPg::EBtreeAmStrategy::GreaterOrEqual) == BTGreaterEqualStrategyNumber);
+    UNIT_ASSERT(static_cast<ui32>(NYql::NPg::EBtreeAmStrategy::Greater) == BTGreaterStrategyNumber);
+}
 
-    Y_UNIT_TEST(TTypeOidConsts) {
-        TTypeDesc typeDesc;
-        typeDesc = LookupType("unknown");
-        UNIT_ASSERT_VALUES_EQUAL(typeDesc.TypeId, UnknownOid);
-        typeDesc = LookupType("any");
-        UNIT_ASSERT_VALUES_EQUAL(typeDesc.TypeId, AnyOid);
-        typeDesc = LookupType("anyarray");
-        UNIT_ASSERT_VALUES_EQUAL(typeDesc.TypeId, AnyArrayOid);
-        typeDesc = LookupType("record");
-        UNIT_ASSERT_VALUES_EQUAL(typeDesc.TypeId, RecordOid);
-        typeDesc = LookupType("varchar");
-        UNIT_ASSERT_VALUES_EQUAL(typeDesc.TypeId, VarcharOid);
-        typeDesc = LookupType("text");
-        UNIT_ASSERT_VALUES_EQUAL(typeDesc.TypeId, TextOid);
-        typeDesc = LookupType("anynonarray");
-        UNIT_ASSERT_VALUES_EQUAL(typeDesc.TypeId, AnyNonArrayOid);
-    }
+Y_UNIT_TEST(TTypeOidConsts) {
+    TTypeDesc typeDesc;
+    typeDesc = LookupType("unknown");
+    UNIT_ASSERT_VALUES_EQUAL(typeDesc.TypeId, UnknownOid);
+    typeDesc = LookupType("any");
+    UNIT_ASSERT_VALUES_EQUAL(typeDesc.TypeId, AnyOid);
+    typeDesc = LookupType("anyarray");
+    UNIT_ASSERT_VALUES_EQUAL(typeDesc.TypeId, AnyArrayOid);
+    typeDesc = LookupType("record");
+    UNIT_ASSERT_VALUES_EQUAL(typeDesc.TypeId, RecordOid);
+    typeDesc = LookupType("varchar");
+    UNIT_ASSERT_VALUES_EQUAL(typeDesc.TypeId, VarcharOid);
+    typeDesc = LookupType("text");
+    UNIT_ASSERT_VALUES_EQUAL(typeDesc.TypeId, TextOid);
+    typeDesc = LookupType("anynonarray");
+    UNIT_ASSERT_VALUES_EQUAL(typeDesc.TypeId, AnyNonArrayOid);
+}
 
-    Y_UNIT_TEST(TRelationOidConsts) {
-        UNIT_ASSERT_VALUES_EQUAL(TypeRelationOid, TypeRelationId);
-        UNIT_ASSERT_VALUES_EQUAL(DatabaseRelationOid, DatabaseRelationId);
-        UNIT_ASSERT_VALUES_EQUAL(TableSpaceRelationOid, TableSpaceRelationId);
-        UNIT_ASSERT_VALUES_EQUAL(SharedDescriptionRelationOid, SharedDescriptionRelationId);
-        UNIT_ASSERT_VALUES_EQUAL(TriggerRelationOid, TriggerRelationId);
-        UNIT_ASSERT_VALUES_EQUAL(InheritsRelationOid, InheritsRelationId);
-        UNIT_ASSERT_VALUES_EQUAL(DescriptionRelationOid, DescriptionRelationId);
-        UNIT_ASSERT_VALUES_EQUAL(AccessMethodRelationOid, AccessMethodRelationId);
-        UNIT_ASSERT_VALUES_EQUAL(NamespaceRelationOid, NamespaceRelationId);
-        UNIT_ASSERT_VALUES_EQUAL(AuthMemRelationOid, AuthMemRelationId);
-        UNIT_ASSERT_VALUES_EQUAL(RelationRelationOid, RelationRelationId);
-    }
+Y_UNIT_TEST(TRelationOidConsts) {
+    UNIT_ASSERT_VALUES_EQUAL(TypeRelationOid, TypeRelationId);
+    UNIT_ASSERT_VALUES_EQUAL(DatabaseRelationOid, DatabaseRelationId);
+    UNIT_ASSERT_VALUES_EQUAL(TableSpaceRelationOid, TableSpaceRelationId);
+    UNIT_ASSERT_VALUES_EQUAL(SharedDescriptionRelationOid, SharedDescriptionRelationId);
+    UNIT_ASSERT_VALUES_EQUAL(TriggerRelationOid, TriggerRelationId);
+    UNIT_ASSERT_VALUES_EQUAL(InheritsRelationOid, InheritsRelationId);
+    UNIT_ASSERT_VALUES_EQUAL(DescriptionRelationOid, DescriptionRelationId);
+    UNIT_ASSERT_VALUES_EQUAL(AccessMethodRelationOid, AccessMethodRelationId);
+    UNIT_ASSERT_VALUES_EQUAL(NamespaceRelationOid, NamespaceRelationId);
+    UNIT_ASSERT_VALUES_EQUAL(AuthMemRelationOid, AuthMemRelationId);
+    UNIT_ASSERT_VALUES_EQUAL(RelationRelationOid, RelationRelationId);
 }
+} // Y_UNIT_TEST_SUITE(TConstantsTests)
diff --git a/yql/essentials/parser/pg_catalog/ut/catalog_ut.cpp b/yql/essentials/parser/pg_catalog/ut/catalog_ut.cpp
index ea2d4f1212a..0dd8e623c14 100644
--- a/yql/essentials/parser/pg_catalog/ut/catalog_ut.cpp
+++ b/yql/essentials/parser/pg_catalog/ut/catalog_ut.cpp
@@ -15,195 +15,195 @@ const TProcDesc& LookupProcByStrArgTypes(const TString& name, const TVector<TStr
 }
 
 Y_UNIT_TEST_SUITE(TTypesTests) {
-    Y_UNIT_TEST(TestMissing) {
-        UNIT_ASSERT_EXCEPTION(LookupType("_foo_bar_"), yexception);
-        UNIT_ASSERT_EXCEPTION(LookupType(0), yexception);
-    }
+Y_UNIT_TEST(TestMissing) {
+    UNIT_ASSERT_EXCEPTION(LookupType("_foo_bar_"), yexception);
+    UNIT_ASSERT_EXCEPTION(LookupType(0), yexception);
+}
 
-    Y_UNIT_TEST(TestOk) {
-        auto ret = LookupType("text");
-        UNIT_ASSERT_VALUES_EQUAL(ret.TypeId, 25);
-        UNIT_ASSERT_VALUES_EQUAL(ret.ArrayTypeId, 1009);
-        UNIT_ASSERT_VALUES_EQUAL(ret.Name, "text");
-        UNIT_ASSERT_VALUES_EQUAL(ret.ElementTypeId, 0);
-        UNIT_ASSERT_VALUES_EQUAL(ret.TypeCollation, DefaultCollationOid);
-        UNIT_ASSERT_VALUES_EQUAL(ret.TypType, ETypType::Base);
-        UNIT_ASSERT(ret.LessProcId);
-        UNIT_ASSERT(ret.EqualProcId);
-        UNIT_ASSERT(ret.CompareProcId);
-        UNIT_ASSERT(ret.HashProcId);
-
-        ret = LookupType("point");
-        UNIT_ASSERT_VALUES_EQUAL(ret.TypeId, 600);
-        UNIT_ASSERT_VALUES_EQUAL(ret.ArrayTypeId, 1017);
-        UNIT_ASSERT_VALUES_EQUAL(ret.Name, "point");
-        UNIT_ASSERT_VALUES_EQUAL(ret.ElementTypeId, LookupType("float8").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(ret.TypType, ETypType::Base);
-        UNIT_ASSERT(ret.TypeSubscriptFuncId);
-        UNIT_ASSERT(!ret.LessProcId);
-        UNIT_ASSERT(!ret.EqualProcId);
-        UNIT_ASSERT(!ret.CompareProcId);
-        UNIT_ASSERT(!ret.HashProcId);
-
-        ret = LookupType(1009);
-        UNIT_ASSERT_VALUES_EQUAL(ret.TypeId, 1009);
-        UNIT_ASSERT_VALUES_EQUAL(ret.ArrayTypeId, 1009);
-        UNIT_ASSERT_VALUES_EQUAL(ret.Name, "_text");
-        UNIT_ASSERT_VALUES_EQUAL(ret.ElementTypeId, 25);
-        UNIT_ASSERT_VALUES_EQUAL(ret.TypeCollation, DefaultCollationOid);
-        UNIT_ASSERT_VALUES_EQUAL(ret.TypType, ETypType::Base);
-    }
+Y_UNIT_TEST(TestOk) {
+    auto ret = LookupType("text");
+    UNIT_ASSERT_VALUES_EQUAL(ret.TypeId, 25);
+    UNIT_ASSERT_VALUES_EQUAL(ret.ArrayTypeId, 1009);
+    UNIT_ASSERT_VALUES_EQUAL(ret.Name, "text");
+    UNIT_ASSERT_VALUES_EQUAL(ret.ElementTypeId, 0);
+    UNIT_ASSERT_VALUES_EQUAL(ret.TypeCollation, DefaultCollationOid);
+    UNIT_ASSERT_VALUES_EQUAL(ret.TypType, ETypType::Base);
+    UNIT_ASSERT(ret.LessProcId);
+    UNIT_ASSERT(ret.EqualProcId);
+    UNIT_ASSERT(ret.CompareProcId);
+    UNIT_ASSERT(ret.HashProcId);
+
+    ret = LookupType("point");
+    UNIT_ASSERT_VALUES_EQUAL(ret.TypeId, 600);
+    UNIT_ASSERT_VALUES_EQUAL(ret.ArrayTypeId, 1017);
+    UNIT_ASSERT_VALUES_EQUAL(ret.Name, "point");
+    UNIT_ASSERT_VALUES_EQUAL(ret.ElementTypeId, LookupType("float8").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(ret.TypType, ETypType::Base);
+    UNIT_ASSERT(ret.TypeSubscriptFuncId);
+    UNIT_ASSERT(!ret.LessProcId);
+    UNIT_ASSERT(!ret.EqualProcId);
+    UNIT_ASSERT(!ret.CompareProcId);
+    UNIT_ASSERT(!ret.HashProcId);
+
+    ret = LookupType(1009);
+    UNIT_ASSERT_VALUES_EQUAL(ret.TypeId, 1009);
+    UNIT_ASSERT_VALUES_EQUAL(ret.ArrayTypeId, 1009);
+    UNIT_ASSERT_VALUES_EQUAL(ret.Name, "_text");
+    UNIT_ASSERT_VALUES_EQUAL(ret.ElementTypeId, 25);
+    UNIT_ASSERT_VALUES_EQUAL(ret.TypeCollation, DefaultCollationOid);
+    UNIT_ASSERT_VALUES_EQUAL(ret.TypType, ETypType::Base);
 }
+} // Y_UNIT_TEST_SUITE(TTypesTests)
 
 Y_UNIT_TEST_SUITE(TFunctionsTests) {
-    Y_UNIT_TEST(TestMissing) {
-        UNIT_ASSERT_EXCEPTION(LookupProcByStrArgTypes("_foo_bar_", {}), yexception);
-    }
+Y_UNIT_TEST(TestMissing) {
+    UNIT_ASSERT_EXCEPTION(LookupProcByStrArgTypes("_foo_bar_", {}), yexception);
+}
 
-    Y_UNIT_TEST(TestMismatchArgTypes) {
-        UNIT_ASSERT_EXCEPTION(LookupProcByStrArgTypes("int4pl", {}), yexception);
-    }
+Y_UNIT_TEST(TestMismatchArgTypes) {
+    UNIT_ASSERT_EXCEPTION(LookupProcByStrArgTypes("int4pl", {}), yexception);
+}
 
-    Y_UNIT_TEST(TestOk) {
-        auto ret = LookupProcByStrArgTypes("int4pl", {"int4", "int4"});
-        UNIT_ASSERT_VALUES_EQUAL(ret.ResultType, LookupType("int4").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes.size(), 2);
-        UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes[0], LookupType("int4").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes[1], LookupType("int4").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(ret.Src, "int4pl");
-        UNIT_ASSERT(ret.Kind == EProcKind::Function);
-
-        ret = LookupProcByStrArgTypes("substring", {"text", "int4", "int4"});
-        UNIT_ASSERT_VALUES_EQUAL(ret.ResultType, LookupType("text").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes.size(), 3);
-        UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes[0], LookupType("text").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes[1], LookupType("int4").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes[2], LookupType("int4").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(ret.Src, "text_substr");
-
-        ret = LookupProcByStrArgTypes("substring", {"text", "int4"});
-        UNIT_ASSERT_VALUES_EQUAL(ret.ResultType, LookupType("text").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes.size(), 2);
-        UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes[0], LookupType("text").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes[1], LookupType("int4").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(ret.Src, "text_substr_no_len");
-
-        ret = LookupProcByStrArgTypes("sum", {"int4"});
-        UNIT_ASSERT(ret.Kind == EProcKind::Aggregate);
-
-        ret = LookupProcByStrArgTypes("row_number", {});
-        UNIT_ASSERT(ret.Kind == EProcKind::Window);
-    }
+Y_UNIT_TEST(TestOk) {
+    auto ret = LookupProcByStrArgTypes("int4pl", {"int4", "int4"});
+    UNIT_ASSERT_VALUES_EQUAL(ret.ResultType, LookupType("int4").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes.size(), 2);
+    UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes[0], LookupType("int4").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes[1], LookupType("int4").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(ret.Src, "int4pl");
+    UNIT_ASSERT(ret.Kind == EProcKind::Function);
+
+    ret = LookupProcByStrArgTypes("substring", {"text", "int4", "int4"});
+    UNIT_ASSERT_VALUES_EQUAL(ret.ResultType, LookupType("text").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes.size(), 3);
+    UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes[0], LookupType("text").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes[1], LookupType("int4").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes[2], LookupType("int4").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(ret.Src, "text_substr");
+
+    ret = LookupProcByStrArgTypes("substring", {"text", "int4"});
+    UNIT_ASSERT_VALUES_EQUAL(ret.ResultType, LookupType("text").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes.size(), 2);
+    UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes[0], LookupType("text").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes[1], LookupType("int4").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(ret.Src, "text_substr_no_len");
+
+    ret = LookupProcByStrArgTypes("sum", {"int4"});
+    UNIT_ASSERT(ret.Kind == EProcKind::Aggregate);
+
+    ret = LookupProcByStrArgTypes("row_number", {});
+    UNIT_ASSERT(ret.Kind == EProcKind::Window);
 }
+} // Y_UNIT_TEST_SUITE(TFunctionsTests)
 
 Y_UNIT_TEST_SUITE(TCastsTests) {
-    Y_UNIT_TEST(TestMissing) {
-        UNIT_ASSERT_EXCEPTION(LookupCast(LookupType("circle").TypeId, LookupType("int8").TypeId), yexception);
-    }
+Y_UNIT_TEST(TestMissing) {
+    UNIT_ASSERT_EXCEPTION(LookupCast(LookupType("circle").TypeId, LookupType("int8").TypeId), yexception);
+}
 
-    Y_UNIT_TEST(TestOk) {
-        auto ret = LookupCast(LookupType("int8").TypeId, LookupType("int4").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(ret.SourceId, LookupType("int8").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(ret.TargetId, LookupType("int4").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(ret.CoercionCode, ECoercionCode::Assignment);
-        UNIT_ASSERT(ret.Method == ECastMethod::Function);
-        UNIT_ASSERT_VALUES_UNEQUAL(ret.FunctionId, 0);
-
-        ret = LookupCast(LookupType("int4").TypeId, LookupType("oid").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(ret.SourceId, LookupType("int4").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(ret.TargetId, LookupType("oid").TypeId);
-        UNIT_ASSERT(ret.Method == ECastMethod::Binary);
-        UNIT_ASSERT_VALUES_EQUAL(ret.FunctionId, 0);
-
-        ret = LookupCast(LookupType("json").TypeId, LookupType("jsonb").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(ret.SourceId, LookupType("json").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(ret.TargetId, LookupType("jsonb").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(ret.FunctionId, 0);
-    }
+Y_UNIT_TEST(TestOk) {
+    auto ret = LookupCast(LookupType("int8").TypeId, LookupType("int4").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(ret.SourceId, LookupType("int8").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(ret.TargetId, LookupType("int4").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(ret.CoercionCode, ECoercionCode::Assignment);
+    UNIT_ASSERT(ret.Method == ECastMethod::Function);
+    UNIT_ASSERT_VALUES_UNEQUAL(ret.FunctionId, 0);
+
+    ret = LookupCast(LookupType("int4").TypeId, LookupType("oid").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(ret.SourceId, LookupType("int4").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(ret.TargetId, LookupType("oid").TypeId);
+    UNIT_ASSERT(ret.Method == ECastMethod::Binary);
+    UNIT_ASSERT_VALUES_EQUAL(ret.FunctionId, 0);
+
+    ret = LookupCast(LookupType("json").TypeId, LookupType("jsonb").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(ret.SourceId, LookupType("json").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(ret.TargetId, LookupType("jsonb").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(ret.FunctionId, 0);
 }
+} // Y_UNIT_TEST_SUITE(TCastsTests)
 
 Y_UNIT_TEST_SUITE(TAggregationsTests) {
-    Y_UNIT_TEST(TestMissing) {
-        UNIT_ASSERT_EXCEPTION(LookupAggregation("foo", {}), yexception);
-    }
+Y_UNIT_TEST(TestMissing) {
+    UNIT_ASSERT_EXCEPTION(LookupAggregation("foo", {}), yexception);
+}
 
-    Y_UNIT_TEST(TestOk) {
-        auto ret = LookupAggregation("sum", {LookupType("int4").TypeId});
-        UNIT_ASSERT_VALUES_EQUAL(ret.TransTypeId, LookupType("int8").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(ret.Name, "sum");
-        UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes.size(), 1);
-        UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes[0], LookupType("int4").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(LookupProc(ret.TransFuncId).Name, "int4_sum");
-        UNIT_ASSERT_VALUES_EQUAL(LookupProc(ret.CombineFuncId).Name, "int8pl");
-        UNIT_ASSERT_VALUES_EQUAL(ret.FinalFuncId, 0);
-        UNIT_ASSERT_VALUES_EQUAL(ret.SerializeFuncId, 0);
-        UNIT_ASSERT_VALUES_EQUAL(ret.DeserializeFuncId, 0);
-
-        ret = LookupAggregation("sum", {LookupType("int8").TypeId});
-        UNIT_ASSERT_VALUES_EQUAL(ret.TransTypeId, LookupType("internal").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(ret.Name, "sum");
-        UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes.size(), 1);
-        UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes[0], LookupType("int8").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(LookupProc(ret.TransFuncId).Name, "int8_avg_accum");
-        UNIT_ASSERT_VALUES_EQUAL(LookupProc(ret.CombineFuncId).Name, "int8_avg_combine");
-        UNIT_ASSERT_VALUES_EQUAL(LookupProc(ret.FinalFuncId).Name, "numeric_poly_sum");
-        UNIT_ASSERT_VALUES_EQUAL(LookupProc(ret.SerializeFuncId).Name, "int8_avg_serialize");
-        UNIT_ASSERT_VALUES_EQUAL(LookupProc(ret.DeserializeFuncId).Name, "int8_avg_deserialize");
-
-        ret = LookupAggregation("xmlagg", {LookupType("xml").TypeId});
-        UNIT_ASSERT_VALUES_EQUAL(ret.TransTypeId, LookupType("xml").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(ret.Name, "xmlagg");
-        UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes.size(), 1);
-        UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes[0], LookupType("xml").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(LookupProc(ret.TransFuncId).Name, "xmlconcat2");
-        UNIT_ASSERT_VALUES_EQUAL(ret.CombineFuncId, 0);
-        UNIT_ASSERT_VALUES_EQUAL(ret.FinalFuncId, 0);
-        UNIT_ASSERT_VALUES_EQUAL(ret.SerializeFuncId, 0);
-        UNIT_ASSERT_VALUES_EQUAL(ret.DeserializeFuncId, 0);
-
-        ret = LookupAggregation("regr_count", {LookupType("float8").TypeId, LookupType("float8").TypeId});
-        UNIT_ASSERT_VALUES_EQUAL(ret.TransTypeId, LookupType("int8").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(ret.Name, "regr_count");
-        UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes.size(), 2);
-        UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes[0], LookupType("float8").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes[1], LookupType("float8").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(LookupProc(ret.TransFuncId).Name, "int8inc_float8_float8");
-        UNIT_ASSERT_VALUES_EQUAL(LookupProc(ret.CombineFuncId).Name, "int8pl");
-        UNIT_ASSERT_VALUES_EQUAL(ret.FinalFuncId, 0);
-        UNIT_ASSERT_VALUES_EQUAL(ret.SerializeFuncId, 0);
-        UNIT_ASSERT_VALUES_EQUAL(ret.DeserializeFuncId, 0);
-    }
+Y_UNIT_TEST(TestOk) {
+    auto ret = LookupAggregation("sum", {LookupType("int4").TypeId});
+    UNIT_ASSERT_VALUES_EQUAL(ret.TransTypeId, LookupType("int8").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(ret.Name, "sum");
+    UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes.size(), 1);
+    UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes[0], LookupType("int4").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(LookupProc(ret.TransFuncId).Name, "int4_sum");
+    UNIT_ASSERT_VALUES_EQUAL(LookupProc(ret.CombineFuncId).Name, "int8pl");
+    UNIT_ASSERT_VALUES_EQUAL(ret.FinalFuncId, 0);
+    UNIT_ASSERT_VALUES_EQUAL(ret.SerializeFuncId, 0);
+    UNIT_ASSERT_VALUES_EQUAL(ret.DeserializeFuncId, 0);
+
+    ret = LookupAggregation("sum", {LookupType("int8").TypeId});
+    UNIT_ASSERT_VALUES_EQUAL(ret.TransTypeId, LookupType("internal").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(ret.Name, "sum");
+    UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes.size(), 1);
+    UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes[0], LookupType("int8").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(LookupProc(ret.TransFuncId).Name, "int8_avg_accum");
+    UNIT_ASSERT_VALUES_EQUAL(LookupProc(ret.CombineFuncId).Name, "int8_avg_combine");
+    UNIT_ASSERT_VALUES_EQUAL(LookupProc(ret.FinalFuncId).Name, "numeric_poly_sum");
+    UNIT_ASSERT_VALUES_EQUAL(LookupProc(ret.SerializeFuncId).Name, "int8_avg_serialize");
+    UNIT_ASSERT_VALUES_EQUAL(LookupProc(ret.DeserializeFuncId).Name, "int8_avg_deserialize");
+
+    ret = LookupAggregation("xmlagg", {LookupType("xml").TypeId});
+    UNIT_ASSERT_VALUES_EQUAL(ret.TransTypeId, LookupType("xml").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(ret.Name, "xmlagg");
+    UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes.size(), 1);
+    UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes[0], LookupType("xml").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(LookupProc(ret.TransFuncId).Name, "xmlconcat2");
+    UNIT_ASSERT_VALUES_EQUAL(ret.CombineFuncId, 0);
+    UNIT_ASSERT_VALUES_EQUAL(ret.FinalFuncId, 0);
+    UNIT_ASSERT_VALUES_EQUAL(ret.SerializeFuncId, 0);
+    UNIT_ASSERT_VALUES_EQUAL(ret.DeserializeFuncId, 0);
+
+    ret = LookupAggregation("regr_count", {LookupType("float8").TypeId, LookupType("float8").TypeId});
+    UNIT_ASSERT_VALUES_EQUAL(ret.TransTypeId, LookupType("int8").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(ret.Name, "regr_count");
+    UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes.size(), 2);
+    UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes[0], LookupType("float8").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(ret.ArgTypes[1], LookupType("float8").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(LookupProc(ret.TransFuncId).Name, "int8inc_float8_float8");
+    UNIT_ASSERT_VALUES_EQUAL(LookupProc(ret.CombineFuncId).Name, "int8pl");
+    UNIT_ASSERT_VALUES_EQUAL(ret.FinalFuncId, 0);
+    UNIT_ASSERT_VALUES_EQUAL(ret.SerializeFuncId, 0);
+    UNIT_ASSERT_VALUES_EQUAL(ret.DeserializeFuncId, 0);
 }
+} // Y_UNIT_TEST_SUITE(TAggregationsTests)
 
 Y_UNIT_TEST_SUITE(TOpClassesTests) {
-    Y_UNIT_TEST(TestMissing) {
-        UNIT_ASSERT_EXCEPTION(LookupDefaultOpClass(EOpClassMethod::Btree, LookupType("json").TypeId), yexception);
-    }
+Y_UNIT_TEST(TestMissing) {
+    UNIT_ASSERT_EXCEPTION(LookupDefaultOpClass(EOpClassMethod::Btree, LookupType("json").TypeId), yexception);
+}
 
-   Y_UNIT_TEST(TestOk) {
-        auto ret = *LookupDefaultOpClass(EOpClassMethod::Btree, LookupType("int4").TypeId);
-        UNIT_ASSERT(ret.Method == EOpClassMethod::Btree);
-        UNIT_ASSERT_VALUES_EQUAL(ret.TypeId, LookupType("int4").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(ret.Name, "int4_ops");
-        UNIT_ASSERT_VALUES_EQUAL(ret.Family, "btree/integer_ops");
-        UNIT_ASSERT_VALUES_EQUAL(ret.FamilyId, 1976);
-
-        ret = *LookupDefaultOpClass(EOpClassMethod::Hash, LookupType("int4").TypeId);
-        UNIT_ASSERT(ret.Method == EOpClassMethod::Hash);
-        UNIT_ASSERT_VALUES_EQUAL(ret.TypeId, LookupType("int4").TypeId);
-        UNIT_ASSERT_VALUES_EQUAL(ret.Name, "int4_ops");
-        UNIT_ASSERT_VALUES_EQUAL(ret.Family, "hash/integer_ops");
-        UNIT_ASSERT_VALUES_EQUAL(ret.FamilyId, 1977);
-   }
+Y_UNIT_TEST(TestOk) {
+    auto ret = *LookupDefaultOpClass(EOpClassMethod::Btree, LookupType("int4").TypeId);
+    UNIT_ASSERT(ret.Method == EOpClassMethod::Btree);
+    UNIT_ASSERT_VALUES_EQUAL(ret.TypeId, LookupType("int4").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(ret.Name, "int4_ops");
+    UNIT_ASSERT_VALUES_EQUAL(ret.Family, "btree/integer_ops");
+    UNIT_ASSERT_VALUES_EQUAL(ret.FamilyId, 1976);
+
+    ret = *LookupDefaultOpClass(EOpClassMethod::Hash, LookupType("int4").TypeId);
+    UNIT_ASSERT(ret.Method == EOpClassMethod::Hash);
+    UNIT_ASSERT_VALUES_EQUAL(ret.TypeId, LookupType("int4").TypeId);
+    UNIT_ASSERT_VALUES_EQUAL(ret.Name, "int4_ops");
+    UNIT_ASSERT_VALUES_EQUAL(ret.Family, "hash/integer_ops");
+    UNIT_ASSERT_VALUES_EQUAL(ret.FamilyId, 1977);
 }
+} // Y_UNIT_TEST_SUITE(TOpClassesTests)
 
 Y_UNIT_TEST_SUITE(TConversionTests) {
-    Y_UNIT_TEST(TestMissing) {
-        UNIT_ASSERT_EXCEPTION(LookupConversion("foo", "bar"), yexception);
-    }
+Y_UNIT_TEST(TestMissing) {
+    UNIT_ASSERT_EXCEPTION(LookupConversion("foo", "bar"), yexception);
+}
 
-   Y_UNIT_TEST(TestOk) {
-        auto procId = LookupConversion("LATIN1", "UTF8").ProcId;
-        UNIT_ASSERT_VALUES_EQUAL(LookupProc(procId).Name, "iso8859_1_to_utf8");
-   }
+Y_UNIT_TEST(TestOk) {
+    auto procId = LookupConversion("LATIN1", "UTF8").ProcId;
+    UNIT_ASSERT_VALUES_EQUAL(LookupProc(procId).Name, "iso8859_1_to_utf8");
 }
+} // Y_UNIT_TEST_SUITE(TConversionTests)
diff --git a/yql/essentials/parser/pg_catalog/ut/ya.make b/yql/essentials/parser/pg_catalog/ut/ya.make
index 0835e9bbf06..264f1bec741 100644
--- a/yql/essentials/parser/pg_catalog/ut/ya.make
+++ b/yql/essentials/parser/pg_catalog/ut/ya.make
@@ -1,5 +1,7 @@
 UNITTEST_FOR(yql/essentials/parser/pg_catalog)
 
+ENABLE(YQL_STYLE_CPP)
+
 SRCS(
     catalog_ut.cpp
     catalog_consts_ut.cpp
diff --git a/yql/essentials/parser/pg_catalog/ya.make b/yql/essentials/parser/pg_catalog/ya.make
index 815bcaa3408..b24d1b47446 100644
--- a/yql/essentials/parser/pg_catalog/ya.make
+++ b/yql/essentials/parser/pg_catalog/ya.make
@@ -1,5 +1,7 @@
 LIBRARY()
 
+#ENABLE(YQL_STYLE_CPP) need to avoid generated files
+
 RESOURCE(data/pg_operator.dat pg_operator.dat)
 RESOURCE(data/pg_proc.dat pg_proc.dat)
 RESOURCE(data/pg_type.dat pg_type.dat)
diff --git a/yql/essentials/parser/proto_ast/antlr3/proto_ast_antlr3.cpp b/yql/essentials/parser/proto_ast/antlr3/proto_ast_antlr3.cpp
index d317de96982..215c8296d9d 100644
--- a/yql/essentials/parser/proto_ast/antlr3/proto_ast_antlr3.cpp
+++ b/yql/essentials/parser/proto_ast/antlr3/proto_ast_antlr3.cpp
@@ -1 +1 @@
-#include "proto_ast_antlr3.h"
\ No newline at end of file
+#include "proto_ast_antlr3.h"
diff --git a/yql/essentials/parser/proto_ast/antlr3/proto_ast_antlr3.h b/yql/essentials/parser/proto_ast/antlr3/proto_ast_antlr3.h
index 878a1d42ba9..a36e2cfda22 100644
--- a/yql/essentials/parser/proto_ast/antlr3/proto_ast_antlr3.h
+++ b/yql/essentials/parser/proto_ast/antlr3/proto_ast_antlr3.h
@@ -5,88 +5,88 @@
 #include <contrib/libs/antlr3_cpp_runtime/include/antlr3.hpp>
 
 namespace NProtoAST {
-    using namespace NAST;
+using namespace NAST;
 
-    template <typename TParser, typename TLexer>
-    class TProtoASTBuilder3 {
-        typedef ANTLR_UINT8 TChar;
+template <typename TParser, typename TLexer>
+class TProtoASTBuilder3 {
+    typedef ANTLR_UINT8 TChar;
 
-    public:
-        TProtoASTBuilder3(TStringBuf data, const TString& queryName = "query", google::protobuf::Arena* arena = nullptr)
-            : QueryName_(queryName)
-            , InputStream_((const TChar*)data.data(), antlr3::ENC_8BIT, data.length(), (TChar*)QueryName_.begin())  // Why the hell antlr needs non-const ptr??
-            , Lexer_(&InputStream_, static_cast<google::protobuf::Arena*>(nullptr))
-            , TokenStream_(ANTLR_SIZE_HINT, Lexer_.get_tokSource())
-            , Parser_(&TokenStream_, arena)
-        {
-        }
+public:
+    TProtoASTBuilder3(TStringBuf data, const TString& queryName = "query", google::protobuf::Arena* arena = nullptr)
+        : QueryName_(queryName)
+        , InputStream_((const TChar*)data.data(), antlr3::ENC_8BIT, data.length(), (TChar*)QueryName_.begin()) // Why the hell antlr needs non-const ptr??
+        , Lexer_(&InputStream_, static_cast<google::protobuf::Arena*>(nullptr))
+        , TokenStream_(ANTLR_SIZE_HINT, Lexer_.get_tokSource())
+        , Parser_(&TokenStream_, arena)
+    {
+    }
 
-        google::protobuf::Message* BuildAST(IErrorCollector& errors) {
-            // TODO: find a better way to break on lexer errors
-            try {
-                Lexer_.ReportErrors(&errors);
-                return Parser_.Parse(Lexer_, &errors);
-            } catch (const TTooManyErrors&) {
-                return nullptr;
-            } catch (...) {
-                errors.Error(0, 0, CurrentExceptionMessage());
-                return nullptr;
-            }
+    google::protobuf::Message* BuildAST(IErrorCollector& errors) {
+        // TODO: find a better way to break on lexer errors
+        try {
+            Lexer_.ReportErrors(&errors);
+            return Parser_.Parse(Lexer_, &errors);
+        } catch (const TTooManyErrors&) {
+            return nullptr;
+        } catch (...) {
+            errors.Error(0, 0, CurrentExceptionMessage());
+            return nullptr;
         }
+    }
 
-    private:
-        TString QueryName_;
+private:
+    TString QueryName_;
 
-        typename TLexer::InputStreamType InputStream_;
-        TLexer Lexer_;
+    typename TLexer::InputStreamType InputStream_;
+    TLexer Lexer_;
 
-        typename TParser::TokenStreamType TokenStream_;
-        TParser Parser_;
-    };
+    typename TParser::TokenStreamType TokenStream_;
+    TParser Parser_;
+};
 
-    template <typename TLexer>
-    class TLexerTokensCollector3 {
-        typedef ANTLR_UINT8 TChar;
+template <typename TLexer>
+class TLexerTokensCollector3 {
+    typedef ANTLR_UINT8 TChar;
 
-    public:
-        TLexerTokensCollector3(TStringBuf data, const char** tokenNames, const TString& queryName = "query")
-            : TokenNames_(tokenNames)
-            , QueryName_(queryName)
-            , InputStream_((const TChar*)data.data(), antlr3::ENC_8BIT, data.length(), (TChar*)QueryName_.begin())
-            , Lexer_(&InputStream_, static_cast<google::protobuf::Arena*>(nullptr))
-        {
-        }
+public:
+    TLexerTokensCollector3(TStringBuf data, const char** tokenNames, const TString& queryName = "query")
+        : TokenNames_(tokenNames)
+        , QueryName_(queryName)
+        , InputStream_((const TChar*)data.data(), antlr3::ENC_8BIT, data.length(), (TChar*)QueryName_.begin())
+        , Lexer_(&InputStream_, static_cast<google::protobuf::Arena*>(nullptr))
+    {
+    }
 
-        void CollectTokens(IErrorCollector& errors, const NSQLTranslation::ILexer::TTokenCallback& onNextToken) {
-            try {
-                Lexer_.ReportErrors(&errors);
-                auto src = Lexer_.get_tokSource();
+    void CollectTokens(IErrorCollector& errors, const NSQLTranslation::ILexer::TTokenCallback& onNextToken) {
+        try {
+            Lexer_.ReportErrors(&errors);
+            auto src = Lexer_.get_tokSource();
 
-                for (;;) {
-                    auto token = src->nextToken();
-                    auto type = token->getType();
-                    const bool isEOF = type == TLexer::CommonTokenType::TOKEN_EOF;
-                    NSQLTranslation::TParsedToken last;
-                    last.Name = isEOF ? "EOF" : TokenNames_[type];
-                    last.Content = token->getText();
-                    last.Line = token->get_line();
-                    last.LinePos = token->get_charPositionInLine();
+            for (;;) {
+                auto token = src->nextToken();
+                auto type = token->getType();
+                const bool isEOF = type == TLexer::CommonTokenType::TOKEN_EOF;
+                NSQLTranslation::TParsedToken last;
+                last.Name = isEOF ? "EOF" : TokenNames_[type];
+                last.Content = token->getText();
+                last.Line = token->get_line();
+                last.LinePos = token->get_charPositionInLine();
 
-                    onNextToken(std::move(last));
-                    if (isEOF) {
-                        break;
-                    }
+                onNextToken(std::move(last));
+                if (isEOF) {
+                    break;
                 }
-            } catch (const TTooManyErrors&) {
-            } catch (...) {
-                errors.Error(0, 0, CurrentExceptionMessage());
             }
+        } catch (const TTooManyErrors&) {
+        } catch (...) {
+            errors.Error(0, 0, CurrentExceptionMessage());
         }
+    }
 
-    private:
-        const char** TokenNames_;
-        TString QueryName_;
-        typename TLexer::InputStreamType InputStream_;
-        TLexer Lexer_;
-    };
+private:
+    const char** TokenNames_;
+    TString QueryName_;
+    typename TLexer::InputStreamType InputStream_;
+    TLexer Lexer_;
+};
 } // namespace NProtoAST
diff --git a/yql/essentials/parser/proto_ast/antlr4/proto_ast_antlr4.h b/yql/essentials/parser/proto_ast/antlr4/proto_ast_antlr4.h
index 12b8b87fea1..e126a150bbc 100644
--- a/yql/essentials/parser/proto_ast/antlr4/proto_ast_antlr4.h
+++ b/yql/essentials/parser/proto_ast/antlr4/proto_ast_antlr4.h
@@ -7,90 +7,87 @@
 #include <yql/essentials/parser/proto_ast/common.h>
 
 #ifdef ERROR
-#undef ERROR
+    #undef ERROR
 #endif
 #include <contrib/libs/antlr4_cpp_runtime/src/antlr4-runtime.h>
 
 namespace NProtoAST {
-    using namespace NAST;
+using namespace NAST;
 
-    template <typename InputType>
-    void InvalidCharacter(IOutputStream& err, const InputType* input);
+template <typename InputType>
+void InvalidCharacter(IOutputStream& err, const InputType* input);
 
-    template <typename TokenType>
-    inline void InvalidToken(IOutputStream& err, const TokenType* token);
+template <typename TokenType>
+inline void InvalidToken(IOutputStream& err, const TokenType* token);
 
-    template <>
-    inline void InvalidToken<antlr4::Token>(IOutputStream& err, const antlr4::Token* token) {
-        if (token) {
-            if (token->getInputStream()) {
-                err << " '" << token->getText() << "'";
-            } else {
-                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;
         }
     }
+}
 
-    template <typename TParser, typename TLexer>
-    class TProtoASTBuilder4 {
-
-    public:
-        TProtoASTBuilder4(
-            TStringBuf data,
-            const TString& queryName = "query",
-            google::protobuf::Arena* arena = nullptr,
-            bool isAmbiguityError = false,
-            bool isAmbiguityDebugging = false
-        )
-            : QueryName_(queryName)
-            , IsAmbiguityError_(isAmbiguityError)
-            , InputStream_(data)
-            , Lexer_(&InputStream_)
-            , TokenStream_(&Lexer_)
-            , Parser_(&TokenStream_, arena)
-        {
-            if (isAmbiguityDebugging) {
-                Parser_
-                    .template getInterpreter<antlr4::atn::ParserATNSimulator>()
-                    ->setPredictionMode(antlr4::atn::PredictionMode::LL_EXACT_AMBIG_DETECTION);
-            }
+template <typename TParser, typename TLexer>
+class TProtoASTBuilder4 {
+public:
+    TProtoASTBuilder4(
+        TStringBuf data,
+        const TString& queryName = "query",
+        google::protobuf::Arena* arena = nullptr,
+        bool isAmbiguityError = false,
+        bool isAmbiguityDebugging = false)
+        : QueryName_(queryName)
+        , IsAmbiguityError_(isAmbiguityError)
+        , InputStream_(data)
+        , Lexer_(&InputStream_)
+        , TokenStream_(&Lexer_)
+        , Parser_(&TokenStream_, arena)
+    {
+        if (isAmbiguityDebugging) {
+            Parser_
+                .template getInterpreter<antlr4::atn::ParserATNSimulator>()
+                ->setPredictionMode(antlr4::atn::PredictionMode::LL_EXACT_AMBIG_DETECTION);
         }
+    }
 
-        google::protobuf::Message* BuildAST(IErrorCollector& errors) {
-            // TODO: find a better way to break on lexer errors
-            typename antlr4::YqlErrorListener listener(&errors, &Parser_.error, IsAmbiguityError_);
-            Parser_.removeErrorListeners();
-            Parser_.addErrorListener(&listener);
-            try {
-                auto result = Parser_.Parse(&errors);
-                Parser_.removeErrorListener(&listener);
-                if (Parser_.error) {
-                    result = nullptr;
-                }
-                Parser_.error = false;
-                return result;
-            } catch (const TTooManyErrors&) {
-                Parser_.removeErrorListener(&listener);
-                Parser_.error = false;
-                return nullptr;
-            } catch (...) {
-                errors.Error(0, 0, CurrentExceptionMessage());
-                Parser_.removeErrorListener(&listener);
-                Parser_.error = false;
-                return nullptr;
+    google::protobuf::Message* BuildAST(IErrorCollector& errors) {
+        // TODO: find a better way to break on lexer errors
+        typename antlr4::YqlErrorListener listener(&errors, &Parser_.error, IsAmbiguityError_);
+        Parser_.removeErrorListeners();
+        Parser_.addErrorListener(&listener);
+        try {
+            auto result = Parser_.Parse(&errors);
+            Parser_.removeErrorListener(&listener);
+            if (Parser_.error) {
+                result = nullptr;
             }
+            Parser_.error = false;
+            return result;
+        } catch (const TTooManyErrors&) {
+            Parser_.removeErrorListener(&listener);
+            Parser_.error = false;
+            return nullptr;
+        } catch (...) {
+            errors.Error(0, 0, CurrentExceptionMessage());
+            Parser_.removeErrorListener(&listener);
+            Parser_.error = false;
+            return nullptr;
         }
+    }
 
-    private:
-        TString QueryName_;
-        bool IsAmbiguityError_;
+private:
+    TString QueryName_;
+    bool IsAmbiguityError_;
 
-        antlr4::ANTLRInputStream InputStream_;
-        TLexer Lexer_;
+    antlr4::ANTLRInputStream InputStream_;
+    TLexer Lexer_;
 
-        antlr4::CommonTokenStream TokenStream_;
-        TParser Parser_;
-    };
+    antlr4::CommonTokenStream TokenStream_;
+    TParser Parser_;
+};
 
 } // namespace NProtoAST
-
diff --git a/yql/essentials/parser/proto_ast/antlr4/ya.make b/yql/essentials/parser/proto_ast/antlr4/ya.make
index 18c68a249bc..22ce23402bc 100644
--- a/yql/essentials/parser/proto_ast/antlr4/ya.make
+++ b/yql/essentials/parser/proto_ast/antlr4/ya.make
@@ -1,5 +1,7 @@
 LIBRARY()
 
+ENABLE(YQL_STYLE_CPP)
+
 PEERDIR(
     yql/essentials/parser/common/antlr4
     yql/essentials/parser/proto_ast
diff --git a/yql/essentials/parser/proto_ast/collect_issues/collect_issues.h b/yql/essentials/parser/proto_ast/collect_issues/collect_issues.h
index 11ba0c86133..92eec6efef7 100644
--- a/yql/essentials/parser/proto_ast/collect_issues/collect_issues.h
+++ b/yql/essentials/parser/proto_ast/collect_issues/collect_issues.h
@@ -1 +1,3 @@
+#pragma once
+
 #include <yql/essentials/parser/common/issue.h>
diff --git a/yql/essentials/parser/proto_ast/collect_issues/ya.make b/yql/essentials/parser/proto_ast/collect_issues/ya.make
index e2e6b681dbb..f7600fb3e1e 100644
--- a/yql/essentials/parser/proto_ast/collect_issues/ya.make
+++ b/yql/essentials/parser/proto_ast/collect_issues/ya.make
@@ -1,5 +1,7 @@
 LIBRARY()
 
+ENABLE(YQL_STYLE_CPP)
+
 PEERDIR(
     yql/essentials/parser/common
 )
diff --git a/yql/essentials/parser/proto_ast/common.h b/yql/essentials/parser/proto_ast/common.h
index be0b5ee0810..806dcab5a73 100644
--- a/yql/essentials/parser/proto_ast/common.h
+++ b/yql/essentials/parser/proto_ast/common.h
@@ -10,48 +10,48 @@
 
 namespace NAST {
 
-    template <typename InputType>
-    void InvalidCharacter(IOutputStream& err, const InputType* input) {
-        wchar32 rune = 0;
-        size_t runeLen = 0;
-        auto begin = input->get_nextChar();
-        auto end = begin + input->get_sizeBuf();
-        if (begin != end && SafeReadUTF8Char(rune, runeLen, begin, end) == RECODE_OK) {
-            err << " '" << TStringBuf((const char*)begin, runeLen) << "' (Unicode character <" << ui32(rune) << ">)";
-        }
+template <typename InputType>
+void InvalidCharacter(IOutputStream& err, const InputType* input) {
+    wchar32 rune = 0;
+    size_t runeLen = 0;
+    auto begin = input->get_nextChar();
+    auto end = begin + input->get_sizeBuf();
+    if (begin != end && SafeReadUTF8Char(rune, runeLen, begin, end) == RECODE_OK) {
+        err << " '" << TStringBuf((const char*)begin, runeLen) << "' (Unicode character <" << ui32(rune) << ">)";
     }
-
-    template <typename TokenType>
-    inline void InvalidToken(IOutputStream& err, const TokenType* token) {
-        if (token) {
-            if (token->get_input()) {
-                err << " '" << token->getText() << "'";
-            } else {
-                err << ABSENCE;
-            }
+}
+
+template <typename TokenType>
+inline void InvalidToken(IOutputStream& err, const TokenType* token) {
+    if (token) {
+        if (token->get_input()) {
+            err << " '" << token->getText() << "'";
+        } else {
+            err << ABSENCE;
         }
     }
+}
 
 } // namespace NAST
 
 namespace NSQLTranslation {
 
-    class IParser {
-    public:
-        virtual ~IParser() = default;
+class IParser {
+public:
+    virtual ~IParser() = default;
 
-        virtual google::protobuf::Message* Parse(
-            const TString& query, const TString& queryName, NAST::IErrorCollector& err,
-            google::protobuf::Arena* arena) = 0;
-    };
+    virtual google::protobuf::Message* Parse(
+        const TString& query, const TString& queryName, NAST::IErrorCollector& err,
+        google::protobuf::Arena* arena) = 0;
+};
 
-    class IParserFactory : public TThrRefBase {
-    public:
-        virtual ~IParserFactory() = default;
+class IParserFactory: public TThrRefBase {
+public:
+    virtual ~IParserFactory() = default;
 
-        virtual std::unique_ptr<IParser> MakeParser() const = 0;
-    };
+    virtual std::unique_ptr<IParser> MakeParser() const = 0;
+};
 
-    using TParserFactoryPtr = TIntrusivePtr<IParserFactory>;
+using TParserFactoryPtr = TIntrusivePtr<IParserFactory>;
 
 } // namespace NSQLTranslation
diff --git a/yql/essentials/parser/proto_ast/gen/multiproto.py b/yql/essentials/parser/proto_ast/gen/multiproto.py
index f2cc39feb63..00bb737ffc8 100644
--- a/yql/essentials/parser/proto_ast/gen/multiproto.py
+++ b/yql/essentials/parser/proto_ast/gen/multiproto.py
@@ -1,113 +1,127 @@
-import os

-import sys

-

-NSPLIT=10

-

-def main(argv):

-    input_dir="."

-    output_dir="."

-    name=sys.argv[1]

-    if len(argv)>2:

-        input_dir=argv[2]

-    if len(argv)>3:

-        output_dir=argv[3]

-    print("name:",name)

-    print("input_dir:",input_dir)

-    print("output_dir:",output_dir)

-

-    in_h=os.path.join(input_dir,name + ".pb.h")

-    in_cpp=os.path.join(input_dir,name + ".pb.cc")

-    out_h=os.path.join(output_dir,name + ".pb.main.h")

-    out_cpp_template=os.path.join(output_dir,name + ".pb.I")

-

-    with open(out_h,"w") as out_file:

-       with open(in_h,"r") as in_file:

-           for line in in_file:

-              line = line.replace("inline void RegisterArenaDtor","void RegisterArenaDtor")

-              out_file.write(line)

-

-    for i in range(0,2 + NSPLIT):

-        with open(out_cpp_template.replace("I","code" + str(i) + ".cc" if i<NSPLIT else "data.cc" if i==NSPLIT else "classes.h"),"w") as out_file:

-            with open(in_cpp,"r") as in_file:

-                line = line.replace("inline ","")

-                statement_index=0

-                current_types=set()

-                is_data_stmt=False

-                extern_data=False

-                extern_code=False

-                in_class_def=False

-                for line in in_file:

-                    if line.startswith("#include") and name + ".pb.h" in line:

-                        out_file.write('#include "' + name + '.pb.main.h"\n')

-                        if i!=NSPLIT+1:

-                            out_file.write('#include "' + name + '.pb.classes.h"\n')

-                        continue

-                    if line.strip()=="PROTOBUF_PRAGMA_INIT_SEG":

-                        out_file.write(line)

-                        break

-                    out_file.write(line)

-                for line in in_file:

-                    line=line.replace("inline ","")

-                    if 'Generated::' in line and line.endswith('_default_instance_._instance,\n'):

-                        line = 'reinterpret_cast<const ::_pb::Message*>(' + line.removesuffix('._instance,\n') + '),'

-                    if line.startswith("#"):

-                        out_file.write(line)

-                        continue

-                    if line.startswith("namespace") or line.startswith("PROTOBUF_NAMESPACE_OPEN"):

-                        open_namespace = True

-                        out_file.write(line)

-                        continue

-                    if (line.startswith("}  // namespace") or line.startswith("PROTOBUF_NAMESPACE_CLOSE")) and open_namespace:

-                        open_namespace = False

-                        out_file.write(line)

-                        continue

-                    if in_class_def:

-                        if (i==NSPLIT+1):

-                           out_file.write(line)

-                        if line.startswith("};"):

-                           in_class_def=False

-                        continue

-                    if line.startswith("PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT"):

-                        # MOD1 MOD2 MOD3 ... type_name varibale_name;

-                        type_name=line.split(" ")[-2]

-                        if type_name in current_types:

-                            out_file.write(line)

-                        continue

-                    if line.startswith("static ") or (line.startswith("const ") and ("[]" in line or "=" in line)) or line.startswith("PROTOBUF_ATTRIBUTE_WEAK") or line.startswith("PROTOBUF_ATTRIBUTE_INIT_PRIORITY2"):

-                        is_data_stmt = True

-                        extern_data = "file_level_metadata" in line or ("descriptor_table" in line and "once" in line)

-                        extern_code = line.startswith("PROTOBUF_ATTRIBUTE_WEAK")

-                    if line.startswith("class"):

-                       in_class_def=True

-                       if i==NSPLIT+1:

-                          out_file.write(line)

-                       continue

-                    if not is_data_stmt and (statement_index % NSPLIT)==i:

-                        if line.startswith("struct"):

-                            current_types.add(line.split(" ")[1])

-                        out_file.write(line)

-                    if is_data_stmt and i==NSPLIT:

-                        if extern_data:

-                           line = line.replace("static ","")

-                        out_file.write(line)

-                    if is_data_stmt and i<NSPLIT:

-                        if extern_data or extern_code:

-                            if extern_data:

-                                line = "extern " + line.replace("static ","").replace(" = {",";")

-                            if extern_code:

-                                if not "PROTOBUF_ATTRIBUTE_WEAK" in line:

-                                    continue

-                                line = "extern " + line.replace(" {",";")

-                            out_file.write(line)

-                            extern_data = False

-                            extern_code = False

-                    if line.startswith("}"):

-                        if is_data_stmt:

-                            is_data_stmt=False

-                            extern_data = False

-                            extern_code = False

-                        else:

-                            statement_index += 1

-

-if __name__ == "__main__":

-    main(sys.argv)

+import os
+import sys
+
+NSPLIT = 10
+
+
+def main(argv):
+    input_dir = "."
+    output_dir = "."
+    name = sys.argv[1]
+    if len(argv) > 2:
+        input_dir = argv[2]
+    if len(argv) > 3:
+        output_dir = argv[3]
+    print("name:", name)
+    print("input_dir:", input_dir)
+    print("output_dir:", output_dir)
+
+    in_h = os.path.join(input_dir, name + ".pb.h")
+    in_cpp = os.path.join(input_dir, name + ".pb.cc")
+    out_h = os.path.join(output_dir, name + ".pb.main.h")
+    out_cpp_template = os.path.join(output_dir, name + ".pb.I")
+
+    with open(out_h, "w") as out_file:
+        with open(in_h, "r") as in_file:
+            for line in in_file:
+                line = line.replace("inline void RegisterArenaDtor", "void RegisterArenaDtor")
+                out_file.write(line)
+
+    for i in range(0, 2 + NSPLIT):
+        with open(
+            out_cpp_template.replace(
+                "I", "code" + str(i) + ".cc" if i < NSPLIT else "data.cc" if i == NSPLIT else "classes.h"
+            ),
+            "w",
+        ) as out_file:
+            with open(in_cpp, "r") as in_file:
+                line = line.replace("inline ", "")
+                statement_index = 0
+                current_types = set()
+                is_data_stmt = False
+                extern_data = False
+                extern_code = False
+                in_class_def = False
+                for line in in_file:
+                    if line.startswith("#include") and name + ".pb.h" in line:
+                        out_file.write('#include "' + name + '.pb.main.h"\n')
+                        if i != NSPLIT + 1:
+                            out_file.write('#include "' + name + '.pb.classes.h"\n')
+                        continue
+                    if line.strip() == "PROTOBUF_PRAGMA_INIT_SEG":
+                        out_file.write(line)
+                        break
+                    out_file.write(line)
+                for line in in_file:
+                    line = line.replace("inline ", "")
+                    if 'Generated::' in line and line.endswith('_default_instance_._instance,\n'):
+                        line = 'reinterpret_cast<const ::_pb::Message*>(' + line.removesuffix('._instance,\n') + '),'
+                    if line.startswith("#"):
+                        out_file.write(line)
+                        continue
+                    if line.startswith("namespace") or line.startswith("PROTOBUF_NAMESPACE_OPEN"):
+                        open_namespace = True
+                        out_file.write(line)
+                        continue
+                    if (
+                        line.startswith("}  // namespace") or line.startswith("PROTOBUF_NAMESPACE_CLOSE")
+                    ) and open_namespace:
+                        open_namespace = False
+                        out_file.write(line)
+                        continue
+                    if in_class_def:
+                        if i == NSPLIT + 1:
+                            out_file.write(line)
+                        if line.startswith("};"):
+                            in_class_def = False
+                        continue
+                    if line.startswith("PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT"):
+                        # MOD1 MOD2 MOD3 ... type_name varibale_name;
+                        type_name = line.split(" ")[-2]
+                        if type_name in current_types:
+                            out_file.write(line)
+                        continue
+                    if (
+                        line.startswith("static ")
+                        or (line.startswith("const ") and ("[]" in line or "=" in line))
+                        or line.startswith("PROTOBUF_ATTRIBUTE_WEAK")
+                        or line.startswith("PROTOBUF_ATTRIBUTE_INIT_PRIORITY2")
+                    ):
+                        is_data_stmt = True
+                        extern_data = "file_level_metadata" in line or ("descriptor_table" in line and "once" in line)
+                        extern_code = line.startswith("PROTOBUF_ATTRIBUTE_WEAK")
+                    if line.startswith("class"):
+                        in_class_def = True
+                        if i == NSPLIT + 1:
+                            out_file.write(line)
+                        continue
+                    if not is_data_stmt and (statement_index % NSPLIT) == i:
+                        if line.startswith("struct"):
+                            current_types.add(line.split(" ")[1])
+                        out_file.write(line)
+                    if is_data_stmt and i == NSPLIT:
+                        if extern_data:
+                            line = line.replace("static ", "")
+                        out_file.write(line)
+                    if is_data_stmt and i < NSPLIT:
+                        if extern_data or extern_code:
+                            if extern_data:
+                                line = "extern " + line.replace("static ", "").replace(" = {", ";")
+                            if extern_code:
+                                if not "PROTOBUF_ATTRIBUTE_WEAK" in line:
+                                    continue
+                                line = "extern " + line.replace(" {", ";")
+                            out_file.write(line)
+                            extern_data = False
+                            extern_code = False
+                    if line.startswith("}"):
+                        if is_data_stmt:
+                            is_data_stmt = False
+                            extern_data = False
+                            extern_code = False
+                        else:
+                            statement_index += 1
+
+
+if __name__ == "__main__":
+    main(sys.argv)
diff --git a/yql/essentials/parser/proto_ast/ya.make b/yql/essentials/parser/proto_ast/ya.make
index 6daae38e176..973da2e40ad 100644
--- a/yql/essentials/parser/proto_ast/ya.make
+++ b/yql/essentials/parser/proto_ast/ya.make
@@ -1,5 +1,9 @@
 LIBRARY()
 
+HEADERS(common.h)
+
+ENABLE(YQL_STYLE_CPP)
+
 PEERDIR(
     contrib/libs/protobuf
     yql/essentials/parser/common