YQL-21370: Support TCoreAttr::Args at SqlCore

#### Support TCoreAttr::Args at SqlCore ✎

- Introduces support for extended SQL flags with arguments in the SqlCore configuration, allowing flags to carry additional parameters for more granular control
- Refactors internal flag handling to use a map-based structure instead of a simple set, enabling storage and processing of flag arguments
- Updates module resolver and translation settings parsing to work with the new extended flag format, ensuring proper flag propagation and application
- Adds new infrastructure for parsing and managing SQL translation flags with arguments, including dedicated parsing logic for specific flag types
- Maintains backward compatibility while enabling new functionality for SQL flag configuration through gateways and command-line options

<a href="https://nda.ya.ru/t/qa0kX64r7DqvtN"><font size="2">Autodescription by Yandex Code Assistant</font></a>
commit_hash:8b26974b3bf4ff2bdaf76715cbb210a8a15e1dad

22 files changed, 201 insertions, 66 deletions

diff --git a/yql/essentials/core/facade/yql_facade.cpp b/yql/essentials/core/facade/yql_facade.cpp
index 63e963397b1..93f64023586 100644
--- a/yql/essentials/core/facade/yql_facade.cpp
+++ b/yql/essentials/core/facade/yql_facade.cpp
@@ -134,16 +134,26 @@ std::function<TString(const TString&, const TString&)> BuildCompositeTokenResolv
 }
 
 TGatewaySQLFlags SQLFlagsFromYson(const NYT::TNode& node) {
-    const auto& list = node["SqlFlags"].AsList();
+    TGatewaySQLFlags flags;
 
-    THashSet<TString> flags(list.size());
-    for (const auto& f : list) {
-        flags.insert(f.AsString());
+    for (const auto& f : node["SqlFlags"].AsList()) {
+        if (f.IsString()) {
+            flags.Set(f.AsString());
+            continue;
+        }
+
+        const auto& name = f["name"].AsString();
+
+        const auto& argList = f["args"].AsList();
+        TVector<TString> args(Reserve(argList.size()));
+        for (const auto& arg : argList) {
+            args.emplace_back(arg.AsString());
+        }
+
+        flags.Set(name, std::move(args));
     }
 
-    return {
-        .Unconditional = std::move(flags),
-    };
+    return flags;
 }
 
 } // namespace
diff --git a/yql/essentials/core/services/mounts/yql_mounts.cpp b/yql/essentials/core/services/mounts/yql_mounts.cpp
index a1dcb8455be..e4ae2414a8e 100644
--- a/yql/essentials/core/services/mounts/yql_mounts.cpp
+++ b/yql/essentials/core/services/mounts/yql_mounts.cpp
@@ -119,7 +119,7 @@ TUserDataTable GetYqlModuleResolverImpl(
     IModuleResolver::TPtr& moduleResolver,
     const TVector<NUserData::TUserData>& userData,
     const THashMap<TString, TString>& clusterMapping,
-    const THashSet<TString>& sqlFlags,
+    const NSQLTranslation::TExtendedSqlFlags& sqlFlags,
     bool optimizeLibraries,
     THolder<TExprContext> ownedCtx,
     TModuleResolver::TModuleChecker moduleChecker)
@@ -160,7 +160,7 @@ TUserDataTable GetYqlModuleResolver(
     IModuleResolver::TPtr& moduleResolver,
     const TVector<NUserData::TUserData>& userData,
     const THashMap<TString, TString>& clusterMapping,
-    const THashSet<TString>& sqlFlags,
+    const NSQLTranslation::TExtendedSqlFlags& sqlFlags,
     bool optimizeLibraries,
     TModuleResolver::TModuleChecker moduleChecker) {
     return GetYqlModuleResolverImpl(&ctx, moduleResolver, userData, clusterMapping, sqlFlags, optimizeLibraries, nullptr, moduleChecker);
diff --git a/yql/essentials/core/services/mounts/yql_mounts.h b/yql/essentials/core/services/mounts/yql_mounts.h
index 672a0acff16..0ed478abc9a 100644
--- a/yql/essentials/core/services/mounts/yql_mounts.h
+++ b/yql/essentials/core/services/mounts/yql_mounts.h
@@ -25,7 +25,7 @@ TUserDataTable GetYqlModuleResolver(
     IModuleResolver::TPtr& moduleResolver,
     const TVector<NUserData::TUserData>& userData,
     const THashMap<TString, TString>& clusterMapping,
-    const THashSet<TString>& sqlFlags,
+    const NSQLTranslation::TExtendedSqlFlags& sqlFlags,
     bool optimizeLibraries = true,
     TModuleResolver::TModuleChecker moduleChecker = {});
 
diff --git a/yql/essentials/core/yql_type_annotation.cpp b/yql/essentials/core/yql_type_annotation.cpp
index 72f1b2d7868..5fe186b8ce1 100644
--- a/yql/essentials/core/yql_type_annotation.cpp
+++ b/yql/essentials/core/yql_type_annotation.cpp
@@ -552,7 +552,7 @@ bool TModuleResolver::AddFromMemory(const TString& fullName, const TString& modu
         settings.Mode = NSQLTranslation::ESqlMode::LIBRARY;
         settings.File = fullName;
         settings.ClusterMapping = ClusterMapping_;
-        settings.Flags = SqlFlags_;
+        ParseTranslationSettings(SqlFlags_, settings);
         settings.SyntaxVersion = syntaxVersion;
         settings.V0Behavior = NSQLTranslation::EV0Behavior::Silent;
         settings.FileAliasPrefix = FileAliasPrefix_;
diff --git a/yql/essentials/core/yql_type_annotation.h b/yql/essentials/core/yql_type_annotation.h
index 20fe0e5c2ce..0011c94e80d 100644
--- a/yql/essentials/core/yql_type_annotation.h
+++ b/yql/essentials/core/yql_type_annotation.h
@@ -17,7 +17,7 @@
 #include <yql/essentials/core/qplayer/storage/interface/yql_qstorage.h>
 #include <yql/essentials/core/layers/layers.h>
 #include <yql/essentials/ast/yql_expr.h>
-#include <yql/essentials/sql/settings/translation_sql_flags.h>
+#include <yql/essentials/sql/settings/flags/flags.h>
 #include <yql/essentials/sql/sql.h>
 #include <yql/essentials/minikql/runtime_settings/runtime_settings.h>
 
@@ -53,16 +53,21 @@ class TModuleResolver : public IModuleResolver {
 public:
     using TModuleChecker = std::function<bool(const TString& query, const TString& fileName, TExprContext& ctx)>;
 
-    TModuleResolver(NSQLTranslation::TTranslators translators, TModulesTable&& modules,
-        ui64 nextUniqueId, const THashMap<TString, TString>& clusterMapping,
-        const THashSet<TString>& sqlFlags, bool optimizeLibraries = true,
-        THolder<TExprContext> ownedCtx = {}, TModuleChecker moduleChecker = {})
+    TModuleResolver(
+        NSQLTranslation::TTranslators translators,
+        TModulesTable&& modules,
+        ui64 nextUniqueId,
+        const THashMap<TString, TString>& clusterMapping,
+        NSQLTranslation::TExtendedSqlFlags sqlFlags,
+        bool optimizeLibraries = true,
+        THolder<TExprContext> ownedCtx = {},
+        TModuleChecker moduleChecker = {})
         : Translators_(std::move(translators))
         , OwnedCtx_(std::move(ownedCtx))
         , LibsContext_(nextUniqueId)
         , Modules_(std::move(modules))
         , ClusterMapping_(clusterMapping)
-        , SqlFlags_(sqlFlags)
+        , SqlFlags_(std::move(sqlFlags))
         , ModuleChecker_(std::move(moduleChecker))
         , OptimizeLibraries_(optimizeLibraries)
     {
@@ -71,17 +76,25 @@ public:
         }
     }
 
-    TModuleResolver(NSQLTranslation::TTranslators translators, const TModulesTable* parentModules,
-        ui64 nextUniqueId, const THashMap<TString, TString>& clusterMapping,
-        const THashSet<TString>& sqlFlags, bool optimizeLibraries, const TSet<TString>& knownPackages, const THashMap<TString,
-        THashMap<int, TLibraryCohesion>>& libs, TString fileAliasPrefix, TModuleChecker moduleChecker)
+    TModuleResolver(
+        NSQLTranslation::TTranslators translators,
+        const TModulesTable* parentModules,
+        ui64 nextUniqueId,
+        const THashMap<TString, TString>& clusterMapping,
+        NSQLTranslation::TExtendedSqlFlags sqlFlags,
+        bool optimizeLibraries,
+        const TSet<TString>& knownPackages,
+        const THashMap<TString,
+        THashMap<int, TLibraryCohesion>>& libs,
+        TString fileAliasPrefix,
+        TModuleChecker moduleChecker)
         : Translators_(std::move(translators))
         , ParentModules_(parentModules)
         , LibsContext_(nextUniqueId)
         , KnownPackages_(knownPackages)
         , Libs_(libs)
         , ClusterMapping_(clusterMapping)
-        , SqlFlags_(sqlFlags)
+        , SqlFlags_(std::move(sqlFlags))
         , ModuleChecker_(std::move(moduleChecker))
         , OptimizeLibraries_(optimizeLibraries)
         , FileAliasPrefix_(std::move(fileAliasPrefix))
@@ -113,8 +126,9 @@ public:
     void SetClusterMapping(const THashMap<TString, TString>& clusterMapping) {
         ClusterMapping_ = clusterMapping;
     }
-    void SetSqlFlags(const THashSet<TString>& flags) {
-        SqlFlags_ = flags;
+
+    void SetSqlFlags(NSQLTranslation::TExtendedSqlFlags flags) {
+        SqlFlags_ = std::move(flags);
     }
 
     void SetModuleChecker(TModuleChecker moduleChecker) {
@@ -162,7 +176,7 @@ private:
     THashMap<TString, THashMap<int, TLibraryCohesion>> Libs_;
     TModulesTable Modules_;
     THashMap<TString, TString> ClusterMapping_;
-    THashSet<TString> SqlFlags_;
+    NSQLTranslation::TExtendedSqlFlags SqlFlags_;
     TModuleChecker ModuleChecker_;
     const bool OptimizeLibraries_;
     THolder<TExprContext::TFreezeGuard> FreezeGuard_;
diff --git a/yql/essentials/providers/common/gateways_utils/gateways_utils.cpp b/yql/essentials/providers/common/gateways_utils/gateways_utils.cpp
index 9028820ffc9..8c5742580a8 100644
--- a/yql/essentials/providers/common/gateways_utils/gateways_utils.cpp
+++ b/yql/essentials/providers/common/gateways_utils/gateways_utils.cpp
@@ -3,22 +3,30 @@
 #include <yql/essentials/providers/common/proto/gateways_config.pb.h>
 #include <yql/essentials/providers/common/provider/yql_provider_names.h>
 
+#include <util/generic/maybe.h>
+
 namespace NYql {
 
-void TGatewaySQLFlags::CollectAllTo(THashSet<TString>& target) const {
-    target.insert(begin(Unconditional), end(Unconditional));
-    target.insert(begin(Activated), end(Activated));
+void TGatewaySQLFlags::Set(const TString& flag, TVector<TString> args) {
+    All_[flag] = std::move(args);
 }
 
-THashSet<TString> TGatewaySQLFlags::All() const {
-    THashSet<TString> all(Unconditional.size() + Activated.size());
-    CollectAllTo(all);
-    return all;
+void TGatewaySQLFlags::ExtendWith(const TGatewaySQLFlags& flags) {
+    Activated_.insert(begin(flags.Activated_), end(flags.Activated_));
+    All_.insert(begin(flags.All_), end(flags.All_));
 }
 
-void TGatewaySQLFlags::ExtendWith(const TGatewaySQLFlags& flags) {
-    Unconditional.insert(begin(flags.Unconditional), end(flags.Unconditional));
-    Activated.insert(begin(flags.Activated), end(flags.Activated));
+NSQLTranslation::TExtendedSqlFlags TGatewaySQLFlags::ToMap(
+    NSQLTranslation::TExtendedSqlFlags map,
+    bool areOnlyActivated) const {
+    for (const auto& [flag, values] : All_) {
+        if (areOnlyActivated && !Activated_.contains(flag)) {
+            continue;
+        }
+
+        map[flag] = values;
+    }
+    return map;
 }
 
 TGatewaySQLFlags TGatewaySQLFlags::From(const TGatewaysConfig& config, const TActivator& isActive) {
@@ -30,18 +38,28 @@ TGatewaySQLFlags TGatewaySQLFlags::From(const TGatewaysConfig& config, const TAc
 
     {
         const auto& simple = config.GetSqlCore().GetTranslationFlags();
-        flags.Unconditional.insert(begin(simple), end(simple));
+        for (const auto& flag : simple) {
+            flags.Set(flag);
+        }
     }
 
     for (const auto& flag : config.GetSqlCore().GetExtendedTranslationFlags()) {
         const auto& name = flag.GetName();
-        YQL_ENSURE(flag.GetArgs().empty(), "Expected an empty SQL flag args");
 
         if (!flag.HasActivation()) {
-            flags.Unconditional.emplace(name);
+            // Unconditionally enable
         } else if (isActive(flag.GetActivation())) {
-            flags.Activated.emplace(name);
+            flags.Activated_.emplace(name);
+        } else {
+            continue;
         }
+
+        TVector<TString> args(Reserve(flag.GetArgs().size()));
+        for (const auto& arg : flag.GetArgs()) {
+            args.emplace_back(arg);
+        }
+
+        flags.Set(name, std::move(args));
     }
 
     return flags;
diff --git a/yql/essentials/providers/common/gateways_utils/gateways_utils.h b/yql/essentials/providers/common/gateways_utils/gateways_utils.h
index 95d91e3687c..68cebd9d76a 100644
--- a/yql/essentials/providers/common/gateways_utils/gateways_utils.h
+++ b/yql/essentials/providers/common/gateways_utils/gateways_utils.h
@@ -1,9 +1,12 @@
 #pragma once
 
 #include <yql/essentials/providers/common/provider/yql_provider_names.h>
+#include <yql/essentials/sql/settings/flags/flags.h>
 #include <yql/essentials/utils/yql_panic.h>
+
 #include <util/generic/hash.h>
 #include <util/generic/hash_set.h>
+#include <util/generic/vector.h>
 
 namespace NYql {
 
@@ -12,17 +15,25 @@ class TActivationPercentage;
 
 using TActivator = std::function<bool(const TActivationPercentage& activation)>;
 
-struct TGatewaySQLFlags {
-    THashSet<TString> Unconditional;
-    THashSet<TString> Activated;
-
-    void CollectAllTo(THashSet<TString>& target) const;
-    THashSet<TString> All() const;
+class TGatewaySQLFlags final {
+public:
+    void Set(const TString& flag, TVector<TString> args = {});
 
+    /// @note that receiver flags preferred
     void ExtendWith(const TGatewaySQLFlags& flags);
 
+    /// @param map is to reuse a container
+    /// @param areOnlyActivated is needed for Activation report
+    NSQLTranslation::TExtendedSqlFlags ToMap(
+        NSQLTranslation::TExtendedSqlFlags map = {},
+        bool areOnlyActivated = false) const;
+
     static TGatewaySQLFlags From(const TGatewaysConfig& config, const TActivator& isActive);
     static TGatewaySQLFlags FromTesting(const TGatewaysConfig& config);
+
+private:
+    THashSet<TString> Activated_;
+    NSQLTranslation::TExtendedSqlFlags All_;
 };
 
 template <typename T>
diff --git a/yql/essentials/sql/settings/flags/flags.cpp b/yql/essentials/sql/settings/flags/flags.cpp
new file mode 100644
index 00000000000..585b2d9f135
--- /dev/null
+++ b/yql/essentials/sql/settings/flags/flags.cpp
@@ -0,0 +1 @@
+#include "flags.h"
diff --git a/yql/essentials/sql/settings/translation_sql_flags.h b/yql/essentials/sql/settings/flags/flags.h
index ba9a3bacc06..4924ff51bd2 100644
--- a/yql/essentials/sql/settings/translation_sql_flags.h
+++ b/yql/essentials/sql/settings/flags/flags.h
@@ -6,6 +6,8 @@ namespace NSQLTranslation {
 
 using TSqlFlags = THashSet<TString>;
 
+using TExtendedSqlFlags = THashMap<TString, TVector<TString>>;
+
 #define TRANSLATOR_FLAGS_IN_MIGRATION_MODE 1
 
 } // namespace NSQLTranslation
diff --git a/yql/essentials/sql/settings/flags/ya.make b/yql/essentials/sql/settings/flags/ya.make
new file mode 100644
index 00000000000..752bc1aa723
--- /dev/null
+++ b/yql/essentials/sql/settings/flags/ya.make
@@ -0,0 +1,11 @@
+LIBRARY()
+
+SRCS(
+    flags.cpp
+)
+
+PEERDIR(
+    util
+)
+
+END()
diff --git a/yql/essentials/sql/settings/translation_settings.cpp b/yql/essentials/sql/settings/translation_settings.cpp
index 70ee8bbc321..81cf2785150 100644
--- a/yql/essentials/sql/settings/translation_settings.cpp
+++ b/yql/essentials/sql/settings/translation_settings.cpp
@@ -2,10 +2,12 @@
 
 #include <yql/essentials/core/issue/yql_issue.h>
 #include <yql/essentials/utils/utf8.h>
+#include <yql/essentials/utils/yql_panic.h>
 
 #include <library/cpp/deprecated/split/split_iterator.h>
 
 #include <util/string/split.h>
+#include <util/string/join.h>
 #include <util/system/env.h>
 
 namespace {
@@ -29,6 +31,11 @@ public:
         return true;
     }
 };
+
+[[noreturn]] TString ThrowBad(TStringBuf flag, const TVector<TString>& args) {
+    YQL_ENSURE(false, "Bad " << flag << "args [" << JoinSeq(", ", args) << "]");
+}
+
 } // namespace
 
 namespace NSQLTranslation {
@@ -163,4 +170,36 @@ bool ParseTranslationSettings(const TString& query, TTranslationSettings& settin
     return parsed.ApplyTo(settings, issues);
 }
 
+void ParseTranslationSettings(const TExtendedSqlFlags& flags, TTranslationSettings& settings) {
+    using TFlagValueParser = std::function<void(const TVector<TString>& args, TTranslationSettings& s)>;
+
+    static const THashMap<TString, TFlagValueParser> Parsers = {
+        {
+            "YqlSelect",
+            [](const TVector<TString>& args, TTranslationSettings& s) {
+                if (args.size() == 1 && args[0] == "disable") {
+                    s.YqlSelect = EYqlSelect::Disable;
+                } else if (args.size() == 1 && args[0] == "auto") {
+                    s.YqlSelect = EYqlSelect::Auto;
+                } else if (args.size() == 1 && args[0] == "force") {
+                    s.YqlSelect = EYqlSelect::Force;
+                } else {
+                    ThrowBad("YqlSelect", args);
+                }
+            },
+        },
+    };
+
+    for (const auto& [flag, args] : flags) {
+        if (args.empty()) {
+            settings.Flags.insert(TString(flag));
+        } else if (const auto* parser = Parsers.FindPtr(flag)) {
+            (*parser)(args, settings);
+        } else {
+            // Ignore unknown valuable flags, like we are
+            // able to ignore TTranslationSettings::Flags.
+        }
+    }
+}
+
 } // namespace NSQLTranslation
diff --git a/yql/essentials/sql/settings/translation_settings.h b/yql/essentials/sql/settings/translation_settings.h
index 633df1ec380..9252d84caf6 100644
--- a/yql/essentials/sql/settings/translation_settings.h
+++ b/yql/essentials/sql/settings/translation_settings.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <yql/essentials/sql/settings/flags/flags.h>
 #include <yql/essentials/core/pg_settings/guc_settings.h>
 #include <yql/essentials/public/langver/yql_langver.h>
 #include <yql/essentials/public/udf_meta/udf_meta.h>
@@ -161,4 +162,6 @@ bool ParseTranslationSettingsFromComments(const TString& query, TParsedSettings&
 
 bool ParseTranslationSettings(const TString& query, TTranslationSettings& settings, NYql::TIssues& issues);
 
+void ParseTranslationSettings(const TExtendedSqlFlags& flags, TTranslationSettings& settings);
+
 } // namespace NSQLTranslation
diff --git a/yql/essentials/sql/settings/translation_sql_flags.cpp b/yql/essentials/sql/settings/translation_sql_flags.cpp
deleted file mode 100644
index cb8ad75c184..00000000000
--- a/yql/essentials/sql/settings/translation_sql_flags.cpp
+++ /dev/null
@@ -1 +0,0 @@
-#include "translation_sql_flags.h"
diff --git a/yql/essentials/sql/settings/ya.make b/yql/essentials/sql/settings/ya.make
index 8fd4832db67..bb13d21302d 100644
--- a/yql/essentials/sql/settings/ya.make
+++ b/yql/essentials/sql/settings/ya.make
@@ -3,7 +3,6 @@ LIBRARY()
 SRCS(
     partitioning.cpp
     translation_settings.cpp
-    translation_sql_flags.cpp
     translator.cpp
 )
 
@@ -16,7 +15,12 @@ PEERDIR(
     yql/essentials/core/issue
     yql/essentials/core/pg_settings
     yql/essentials/public/issue/protos
+    yql/essentials/sql/settings/flags
     yql/essentials/utils
 )
 
 END()
+
+RECURSE(
+    flags
+)
diff --git a/yql/essentials/tools/sql2yql/sql2yql.cpp b/yql/essentials/tools/sql2yql/sql2yql.cpp
index e6b7080628f..85ff6111c49 100644
--- a/yql/essentials/tools/sql2yql/sql2yql.cpp
+++ b/yql/essentials/tools/sql2yql/sql2yql.cpp
@@ -302,8 +302,12 @@ int BuildAST(int argc, char** argv) {
 
     IOutputStream& out = outFile ? *outFile.Get() : Cout;
 
+    NSQLTranslation::TExtendedSqlFlags sqlFlags;
+    for (auto&& flag : std::move(flags)) {
+        sqlFlags[flag] = {};
+    }
     if (gatewaysConfig) {
-        NYql::TGatewaySQLFlags::FromTesting(*gatewaysConfig).CollectAllTo(flags);
+        sqlFlags = NYql::TGatewaySQLFlags::FromTesting(*gatewaysConfig).ToMap(std::move(sqlFlags));
     }
 
     if (!res.Has("query") && queryFiles.empty()) {
@@ -375,7 +379,7 @@ int BuildAST(int argc, char** argv) {
             settings.Arena = &arena;
             settings.LangVer = langVer;
             settings.ClusterMapping = clusterMapping;
-            settings.Flags = flags;
+            NSQLTranslation::ParseTranslationSettings(sqlFlags, settings);
             settings.SyntaxVersion = syntaxVersion;
             settings.AnsiLexer = res.Has("ansi-lexer");
             settings.WarnOnV0 = false;
diff --git a/yql/essentials/tools/yql_facade_run/yql_facade_run.cpp b/yql/essentials/tools/yql_facade_run/yql_facade_run.cpp
index a34886011ba..98b43d63c7c 100644
--- a/yql/essentials/tools/yql_facade_run/yql_facade_run.cpp
+++ b/yql/essentials/tools/yql_facade_run/yql_facade_run.cpp
@@ -204,6 +204,8 @@ void TFacadeRunOptions::Parse(int argc, const char** argv) {
         }
     }
 
+    THashSet<TString> sqlFlags;
+
     NLastGetopt::TOpts opts = NLastGetopt::TOpts::Default();
 
     opts.AddHelpOption();
@@ -359,7 +361,7 @@ void TFacadeRunOptions::Parse(int argc, const char** argv) {
     opts.AddLongOption("full-stat", "Output full execution statistics").Optional().NoArgument().SetFlag(&FullStatistics);
     opts.AddLongOption("diagnostics", "Output diagnostics").Optional().NoArgument().SetFlag(&PrintDiagnostics);
 
-    opts.AddLongOption("sql-flags", "SQL translator pragma flags").SplitHandler(&SqlFlags, ',');
+    opts.AddLongOption("sql-flags", "SQL translator pragma flags").SplitHandler(&sqlFlags, ',');
     opts.AddLongOption("syntax-version", "SQL syntax version").StoreResult(&SyntaxVersion).DefaultValue(1);
     opts.AddLongOption("ansi-lexer", "Use ansi lexer").NoArgument().SetFlag(&AnsiLexer);
     opts.AddLongOption("assume-ydb-on-slash", "Assume YDB provider if cluster name starts with '/'").NoArgument().SetFlag(&AssumeYdbOnClusterWithSlash);
@@ -508,15 +510,18 @@ void TFacadeRunOptions::Parse(int argc, const char** argv) {
         GatewaysConfig = ParseProtoFromResource<TGatewaysConfig>("gateways.conf");
     }
 
-    if (QPlayerContext.CanRead()) {
-        auto sqlFlags = SQLFlagsFromQContext(QPlayerContext);
-        if (GatewaysPatch) {
-            // Gateways Patch is used for experimental features
-            sqlFlags.ExtendWith(TGatewaySQLFlags::FromTesting(*GatewaysPatch));
+    {
+        TGatewaySQLFlags gatewaySqlFlags;
+        for (const auto& flag : sqlFlags) {
+            gatewaySqlFlags.Set(flag);
+        }
+        if (QPlayerContext.CanRead()) {
+            gatewaySqlFlags.ExtendWith(SQLFlagsFromQContext(QPlayerContext));
+        }
+        if (GatewaysConfig) {
+            gatewaySqlFlags.ExtendWith(TGatewaySQLFlags::FromTesting(*GatewaysConfig));
         }
-        sqlFlags.CollectAllTo(SqlFlags);
-    } else if (GatewaysConfig) {
-        TGatewaySQLFlags::FromTesting(*GatewaysConfig).CollectAllTo(SqlFlags);
+        SqlFlags = std::move(gatewaySqlFlags).ToMap();
     }
 
     if (!FsConfig) {
@@ -842,7 +847,7 @@ int TFacadeRunner::DoRun(TProgramFactory& factory) {
         settings.Arena = &arena;
         settings.PgParser = EProgramType::Pg == RunOptions_.ProgramType;
         settings.ClusterMapping = ClusterMapping_;
-        settings.Flags = RunOptions_.SqlFlags;
+        ParseTranslationSettings(RunOptions_.SqlFlags, settings);
         settings.SyntaxVersion = RunOptions_.SyntaxVersion;
         settings.AnsiLexer = RunOptions_.AnsiLexer;
         settings.TestAntlr4 = RunOptions_.TestAntlr4;
diff --git a/yql/essentials/tools/yql_facade_run/yql_facade_run.h b/yql/essentials/tools/yql_facade_run/yql_facade_run.h
index f132c24d98b..aea93600061 100644
--- a/yql/essentials/tools/yql_facade_run/yql_facade_run.h
+++ b/yql/essentials/tools/yql_facade_run/yql_facade_run.h
@@ -86,7 +86,7 @@ public:
     TString OperationId;
     TQContext QPlayerContext;
 
-    THashSet<TString> SqlFlags;
+    NSQLTranslation::TExtendedSqlFlags SqlFlags;
     ui16 SyntaxVersion = 1;
     bool AnsiLexer = false;
     bool TestAntlr4 = false;
diff --git a/yql/essentials/udfs/language/yql/sql2yql.cpp b/yql/essentials/udfs/language/yql/sql2yql.cpp
index 82ae3b96e82..0e468011be8 100644
--- a/yql/essentials/udfs/language/yql/sql2yql.cpp
+++ b/yql/essentials/udfs/language/yql/sql2yql.cpp
@@ -1,5 +1,6 @@
 #include "sql2yql.h"
 
+#include <yql/essentials/sql/settings/flags/flags.h>
 #include <yql/essentials/sql/sql.h>
 #include <yql/essentials/sql/v1/sql.h>
 #include <yql/essentials/sql/v1/lexer/antlr4/lexer.h>
@@ -37,9 +38,10 @@ void ParseGatewaysConfig(TStringBuf cfg, NSQLTranslation::TTranslationSettings&
         ythrow yexception() << "Failed to parse gateways config";
     }
 
-    GetClusterMappingFromGateways(config, settings.ClusterMapping);
+    NSQLTranslation::TExtendedSqlFlags sqlFlags = NYql::TGatewaySQLFlags::FromTesting(config).ToMap();
 
-    NYql::TGatewaySQLFlags::FromTesting(config).CollectAllTo(settings.Flags);
+    GetClusterMappingFromGateways(config, settings.ClusterMapping);
+    NSQLTranslation::ParseTranslationSettings(sqlFlags, settings);
 }
 
 void ParseTranslationSettings(const TSql2YqlInput& input, NSQLTranslation::TTranslationSettings& settings) {
diff --git a/yql/tools/yqlrun/yqlrun.cpp b/yql/tools/yqlrun/yqlrun.cpp
index 3de4397d8a4..31b9e04b69a 100644
--- a/yql/tools/yqlrun/yqlrun.cpp
+++ b/yql/tools/yqlrun/yqlrun.cpp
@@ -186,6 +186,11 @@ int RunUI(int argc, const char* argv[])
 
     NPg::GetSqlLanguageParser()->Freeze();
 
+    NSQLTranslation::TExtendedSqlFlags extendedSqlFlags;
+    for (const auto& flag : sqlFlags) {
+        extendedSqlFlags[flag] = {};
+    }
+
     THolder<TGatewaysConfig> gatewaysConfig;
     if (!gatewaysCfgFile.empty()) {
         gatewaysConfig = ParseProtoConfig<TGatewaysConfig>(gatewaysCfgFile);
@@ -193,7 +198,8 @@ int RunUI(int argc, const char* argv[])
             return -1;
         }
 
-        TGatewaySQLFlags::FromTesting(*gatewaysConfig).CollectAllTo(sqlFlags);
+        extendedSqlFlags = TGatewaySQLFlags::FromTesting(*gatewaysConfig)
+                               .ToMap(std::move(extendedSqlFlags));
     }
 
     THolder<TFileStorageConfig> fsConfig;
@@ -242,7 +248,12 @@ int RunUI(int argc, const char* argv[])
             return -1;
         }
 
-        moduleResolver = std::make_shared<TModuleResolver>(translators, std::move(modules), ctx.NextUniqueId, clusterMapping, sqlFlags);
+        moduleResolver = std::make_shared<TModuleResolver>(
+            translators,
+            std::move(modules),
+            ctx.NextUniqueId,
+            clusterMapping,
+            extendedSqlFlags);
     } else {
         if (!GetYqlDefaultModuleResolver(ctx, moduleResolver, clusterMapping)) {
             Cerr << "Errors loading default YQL libraries:" << Endl;
diff --git a/yt/yql/providers/yt/provider/ya.make b/yt/yql/providers/yt/provider/ya.make
index c54cc739bdf..aaf05fa330e 100644
--- a/yt/yql/providers/yt/provider/ya.make
+++ b/yt/yql/providers/yt/provider/ya.make
@@ -88,6 +88,7 @@ PEERDIR(
     yql/essentials/public/langver
     yql/essentials/public/udf
     yql/essentials/sql
+    yql/essentials/sql/settings/flags
     yql/essentials/sql/v1
     yql/essentials/sql/v1/lexer/antlr4
     yql/essentials/sql/v1/lexer/antlr4_ansi
diff --git a/yt/yql/providers/yt/provider/yql_yt_provider.h b/yt/yql/providers/yt/provider/yql_yt_provider.h
index 378fb204ede..7d87ebb32fc 100644
--- a/yt/yql/providers/yt/provider/yql_yt_provider.h
+++ b/yt/yql/providers/yt/provider/yql_yt_provider.h
@@ -8,7 +8,7 @@
 #include <yt/yql/providers/yt/common/yql_yt_settings.h>
 #include <yt/yql/providers/yt/lib/full_capture/yql_yt_full_capture.h>
 #include <yt/yql/providers/yt/lib/row_spec/yql_row_spec.h>
-#include <yql/essentials/sql/settings/translation_sql_flags.h>
+#include <yql/essentials/sql/settings/flags/flags.h>
 #include <yql/essentials/core/cbo/cbo_optimizer_new.h>
 #include <yql/essentials/core/dq_integration/yql_dq_integration.h>
 #include <yql/essentials/core/dq_integration/yql_dq_helper.h>
diff --git a/yt/yql/providers/yt/provider/yql_yt_table_desc.h b/yt/yql/providers/yt/provider/yql_yt_table_desc.h
index 2b0bef33530..c844452234a 100644
--- a/yt/yql/providers/yt/provider/yql_yt_table_desc.h
+++ b/yt/yql/providers/yt/provider/yql_yt_table_desc.h
@@ -3,7 +3,7 @@
 #include <yql/essentials/ast/yql_expr.h>
 #include <yql/essentials/core/url_lister/interface/url_lister_manager.h>
 #include <yql/essentials/core/yql_udf_resolver.h>
-#include <yql/essentials/sql/settings/translation_sql_flags.h>
+#include <yql/essentials/sql/settings/flags/flags.h>
 
 #include <library/cpp/random_provider/random_provider.h>