YQL-20086 sql/v1

commit_hash:55bc611cdaa0d8a0fc3c4c7708ed9f17cc4976cf

1 files changed, 138 insertions, 124 deletions

diff --git a/yql/essentials/sql/v1/aggregation.cpp b/yql/essentials/sql/v1/aggregation.cpp
index 87a1859f208..e7a9d2a1fe9 100644
--- a/yql/essentials/sql/v1/aggregation.cpp
+++ b/yql/essentials/sql/v1/aggregation.cpp
@@ -15,25 +15,25 @@ using namespace NYql;
 namespace NSQLTranslationV1 {
 
 namespace {
-    bool BlockWindowAggregationWithoutFrameSpec(TPosition pos, TStringBuf name, ISource* src, TContext& ctx) {
-        if (src) {
-            auto winNamePtr = src->GetWindowName();
-            if (winNamePtr) {
-                auto winSpecPtr = src->FindWindowSpecification(ctx, *winNamePtr);
-                if (!winSpecPtr) {
-                    ctx.Error(pos) << "Failed to use aggregation function " << name << " without window specification or in wrong place";
-                    return true;
-                }
+bool BlockWindowAggregationWithoutFrameSpec(TPosition pos, TStringBuf name, ISource* src, TContext& ctx) {
+    if (src) {
+        auto winNamePtr = src->GetWindowName();
+        if (winNamePtr) {
+            auto winSpecPtr = src->FindWindowSpecification(ctx, *winNamePtr);
+            if (!winSpecPtr) {
+                ctx.Error(pos) << "Failed to use aggregation function " << name << " without window specification or in wrong place";
+                return true;
             }
         }
-        return false;
     }
+    return false;
+}
 
-    bool ShouldEmitAggApply(const TContext& ctx) {
-        const bool blockEngineEnabled = ctx.BlockEngineEnable || ctx.BlockEngineForce;
-        return ctx.EmitAggApply.GetOrElse(blockEngineEnabled);
-    }
+bool ShouldEmitAggApply(const TContext& ctx) {
+    const bool blockEngineEnabled = ctx.BlockEngineEnable || ctx.BlockEngineForce;
+    return ctx.EmitAggApply.GetOrElse(blockEngineEnabled);
 }
+} // namespace
 
 static const THashSet<TString> AggApplyFuncs = {
     "count_traits_factory",
@@ -44,13 +44,16 @@ static const THashSet<TString> AggApplyFuncs = {
     "some_traits_factory",
 };
 
-class TAggregationFactory : public IAggregation {
+class TAggregationFactory: public IAggregation {
 public:
     TAggregationFactory(TPosition pos, const TString& name, const TString& func, EAggregateMode aggMode,
-        bool multi = false, bool validateArgs = true)
-        : IAggregation(pos, name, func, aggMode), Factory_(!func.empty() ?
-            BuildBind(Pos_, aggMode == EAggregateMode::OverWindow || aggMode == EAggregateMode::OverWindowDistinct ? "window_module" : "aggregate_module", func) : nullptr),
-        Multi_(multi), ValidateArgs_(validateArgs), DynamicFactory_(!Factory_)
+                        bool multi = false, bool validateArgs = true)
+        : IAggregation(pos, name, func, aggMode)
+        , Factory_(!func.empty() ? BuildBind(Pos_, aggMode == EAggregateMode::OverWindow || aggMode == EAggregateMode::OverWindowDistinct ? "window_module" : "aggregate_module", func) : nullptr)
+        ,
+        Multi_(multi)
+        , ValidateArgs_(validateArgs)
+        , DynamicFactory_(!Factory_)
     {
         if (aggMode != EAggregateMode::OverWindow && aggMode != EAggregateMode::OverWindowDistinct && !func.empty() && AggApplyFuncs.contains(func)) {
             AggApplyName_ = func.substr(0, func.size() - 15);
@@ -75,7 +78,7 @@ protected:
 
             if (expectedArgs != exprs.size()) {
                 ctx.Error(Pos_) << "Aggregation function " << (isFactory ? "factory " : "") << Name_
-                    << " requires exactly " << expectedArgs << " argument(s), given: " << exprs.size();
+                                << " requires exactly " << expectedArgs << " argument(s), given: " << exprs.size();
                 return false;
             }
         }
@@ -141,13 +144,13 @@ protected:
             }
 
             return Y("Apply", Factory_, (DynamicFactory_ ? Y("ListItemType", type) : type),
-              extractor);
+                     extractor);
         }
 
         return Y("MultiAggregate",
-            Y("ListItemType", type),
-            extractor,
-            Factory_);
+                 Y("ListItemType", type),
+                 extractor,
+                 Factory_);
     }
 
     bool DoInit(TContext& ctx, ISource* src) override {
@@ -209,10 +212,8 @@ protected:
             }
 
             if (AggMode_ == EAggregateMode::OverWindow) {
-                Factory_ = BuildLambda(Pos_, Y("type", "extractor"), Y("block", Q(Y(
-                    Y("let", "x", Y("Apply", Factory_, "type", "extractor")),
-                    Y("return", Y("ToWindowTraits", "x"))
-                ))));
+                Factory_ = BuildLambda(Pos_, Y("type", "extractor"), Y("block", Q(Y(Y("let", "x", Y("Apply", Factory_, "type", "extractor")),
+                                                                                    Y("return", Y("ToWindowTraits", "x"))))));
             }
         }
 
@@ -231,11 +232,12 @@ private:
     bool DynamicFactory_;
 };
 
-class TAggregationFactoryImpl final : public TAggregationFactory {
+class TAggregationFactoryImpl final: public TAggregationFactory {
 public:
     TAggregationFactoryImpl(TPosition pos, const TString& name, const TString& func, EAggregateMode aggMode, bool multi)
         : TAggregationFactory(pos, name, func, aggMode, multi)
-    {}
+    {
+    }
 
 private:
     TNodePtr DoClone() const final {
@@ -247,19 +249,20 @@ TAggregationPtr BuildFactoryAggregation(TPosition pos, const TString& name, cons
     return new TAggregationFactoryImpl(pos, name, func, aggMode, multi);
 }
 
-class TKeyPayloadAggregationFactory final : public TAggregationFactory {
+class TKeyPayloadAggregationFactory final: public TAggregationFactory {
 public:
     TKeyPayloadAggregationFactory(TPosition pos, const TString& name, const TString& factory, EAggregateMode aggMode)
         : TAggregationFactory(pos, name, factory, aggMode)
         , FakeSource_(BuildFakeSource(pos))
-    {}
+    {
+    }
 
 private:
     bool InitAggr(TContext& ctx, bool isFactory, ISource* src, TAstListNode& node, const TVector<TNodePtr>& exprs) final {
         ui32 adjustArgsCount = isFactory ? 0 : 2;
         if (exprs.size() < adjustArgsCount || exprs.size() > 1 + adjustArgsCount) {
             ctx.Error(Pos_) << "Aggregation function " << (isFactory ? "factory " : "") << Name_ << " requires "
-                << adjustArgsCount << " or " << (1 + adjustArgsCount) << " arguments, given: " << exprs.size();
+                            << adjustArgsCount << " or " << (1 + adjustArgsCount) << " arguments, given: " << exprs.size();
             return false;
         }
         if (BlockWindowAggregationWithoutFrameSpec(Pos_, GetName(), src, ctx)) {
@@ -313,8 +316,8 @@ private:
         Y_UNUSED(ctx);
         Y_UNUSED(allowAggApply);
         auto apply = Y("Apply", Factory_, type,
-            BuildLambda(Pos_, Y("row"), many ? Y("Unwrap", Key_) : Key_),
-            BuildLambda(Pos_, Y("row"), many ? Y("Unwrap", Payload_) : Payload_));
+                       BuildLambda(Pos_, Y("row"), many ? Y("Unwrap", Key_) : Key_),
+                       BuildLambda(Pos_, Y("row"), many ? Y("Unwrap", Payload_) : Payload_));
         AddFactoryArguments(apply);
         return apply;
     }
@@ -362,11 +365,12 @@ TAggregationPtr BuildKeyPayloadFactoryAggregation(TPosition pos, const TString&
     return new TKeyPayloadAggregationFactory(pos, name, factory, aggMode);
 }
 
-class TPayloadPredicateAggregationFactory final : public TAggregationFactory {
+class TPayloadPredicateAggregationFactory final: public TAggregationFactory {
 public:
     TPayloadPredicateAggregationFactory(TPosition pos, const TString& name, const TString& factory, EAggregateMode aggMode)
         : TAggregationFactory(pos, name, factory, aggMode)
-    {}
+    {
+    }
 
 private:
     bool InitAggr(TContext& ctx, bool isFactory, ISource* src, TAstListNode& node, const TVector<TNodePtr>& exprs) final {
@@ -389,8 +393,7 @@ private:
         }
 
         if (exprs.size() != adjustArgsCount) {
-            ctx.Error(Pos_) << "Aggregation function " << (isFactory ? "factory " : "") << Name_ << " requires " <<
-                adjustArgsCount << " arguments, given: " << exprs.size();
+            ctx.Error(Pos_) << "Aggregation function " << (isFactory ? "factory " : "") << Name_ << " requires " << adjustArgsCount << " arguments, given: " << exprs.size();
             return false;
         }
 
@@ -435,8 +438,8 @@ private:
         Y_UNUSED(ctx);
         Y_UNUSED(allowAggApply);
         return Y("Apply", Factory_, type,
-            BuildLambda(Pos_, Y("row"), many ? Y("Unwrap", Payload_) : Payload_),
-            BuildLambda(Pos_, Y("row"), many ? Y("Unwrap", Predicate_) : Predicate_));
+                 BuildLambda(Pos_, Y("row"), many ? Y("Unwrap", Payload_) : Payload_),
+                 BuildLambda(Pos_, Y("row"), many ? Y("Unwrap", Predicate_) : Predicate_));
     }
 
     std::vector<ui32> GetFactoryColumnIndices() const final {
@@ -470,18 +473,20 @@ TAggregationPtr BuildPayloadPredicateFactoryAggregation(TPosition pos, const TSt
     return new TPayloadPredicateAggregationFactory(pos, name, factory, aggMode);
 }
 
-class TTwoArgsAggregationFactory final : public TAggregationFactory {
+class TTwoArgsAggregationFactory final: public TAggregationFactory {
 public:
     TTwoArgsAggregationFactory(TPosition pos, const TString& name, const TString& factory, EAggregateMode aggMode)
         : TAggregationFactory(pos, name, factory, aggMode)
-    {}
+    {
+    }
 
 private:
     bool InitAggr(TContext& ctx, bool isFactory, ISource* src, TAstListNode& node, const TVector<TNodePtr>& exprs) final {
         ui32 adjustArgsCount = isFactory ? 0 : 2;
         if (exprs.size() != adjustArgsCount) {
-            ctx.Error(Pos_) << "Aggregation function " << (isFactory ? "factory " : "") << Name_ << " requires " <<
-                adjustArgsCount << " arguments, given: " << exprs.size();
+            ctx.Error(Pos_) << "Aggregation function " << (isFactory ? "factory " : "")
+                            << Name_ << " requires " << adjustArgsCount << " arguments, given: "
+                            << exprs.size();
             return false;
         }
 
@@ -551,14 +556,15 @@ TAggregationPtr BuildTwoArgsFactoryAggregation(TPosition pos, const TString& nam
     return new TTwoArgsAggregationFactory(pos, name, factory, aggMode);
 }
 
-class THistogramAggregationFactory final : public TAggregationFactory {
+class THistogramAggregationFactory final: public TAggregationFactory {
 public:
     THistogramAggregationFactory(TPosition pos, const TString& name, const TString& factory, EAggregateMode aggMode)
         : TAggregationFactory(pos, name, factory, aggMode)
         , FakeSource_(BuildFakeSource(pos))
         , Weight_(Y("Double", Q("1.0")))
         , Intervals_(Y("Uint32", Q("100")))
-    {}
+    {
+    }
 
 private:
     bool InitAggr(TContext& ctx, bool isFactory, ISource* src, TAstListNode& node, const TVector<TNodePtr>& exprs) final {
@@ -578,18 +584,18 @@ private:
             /// \todo: solve it with named arguments
             const auto integer = exprs.back()->IsIntegerLiteral();
             switch (exprs.size()) {
-            case 2U:
-                if (!integer) {
-                    Weight_ = exprs.back();
-                }
-                break;
-            case 3U:
-                if (!integer) {
-                    ctx.Error(Pos_) << "Aggregation function " << Name_ << " for case with 3 arguments should have third argument of integer type";
-                    return false;
-                }
-                Weight_ = exprs[1];
-                break;
+                case 2U:
+                    if (!integer) {
+                        Weight_ = exprs.back();
+                    }
+                    break;
+                case 3U:
+                    if (!integer) {
+                        ctx.Error(Pos_) << "Aggregation function " << Name_ << " for case with 3 arguments should have third argument of integer type";
+                        return false;
+                    }
+                    Weight_ = exprs[1];
+                    break;
             }
             if (exprs.size() >= 2 && integer) {
                 Intervals_ = Y("Cast", exprs.back(), Q("Uint32"));
@@ -617,8 +623,8 @@ private:
         Y_UNUSED(ctx);
         Y_UNUSED(allowAggApply);
         auto apply = Y("Apply", Factory_, type,
-            BuildLambda(Pos_, Y("row"), many ? Y("Unwrap", Expr_) : Expr_),
-            BuildLambda(Pos_, Y("row"), many ? Y("Unwrap", Weight_) : Weight_));
+                       BuildLambda(Pos_, Y("row"), many ? Y("Unwrap", Expr_) : Expr_),
+                       BuildLambda(Pos_, Y("row"), many ? Y("Unwrap", Weight_) : Weight_));
         AddFactoryArguments(apply);
         return apply;
     }
@@ -650,7 +656,7 @@ TAggregationPtr BuildHistogramFactoryAggregation(TPosition pos, const TString& n
     return new THistogramAggregationFactory(pos, name, factory, aggMode);
 }
 
-class TLinearHistogramAggregationFactory final : public TAggregationFactory {
+class TLinearHistogramAggregationFactory final: public TAggregationFactory {
 public:
     TLinearHistogramAggregationFactory(TPosition pos, const TString& name, const TString& factory, EAggregateMode aggMode)
         : TAggregationFactory(pos, name, factory, aggMode)
@@ -658,7 +664,8 @@ public:
         , BinSize_(Y("Double", Q("10.0")))
         , Minimum_(Y("Double", Q(ToString(-1.0 * Max<double>()))))
         , Maximum_(Y("Double", Q(ToString(Max<double>()))))
-    {}
+    {
+    }
 
 private:
     bool InitAggr(TContext& ctx, bool isFactory, ISource* src, TAstListNode& node, const TVector<TNodePtr>& exprs) final {
@@ -697,8 +704,8 @@ private:
         Y_UNUSED(ctx);
         Y_UNUSED(allowAggApply);
         return Y("Apply", Factory_, type,
-            BuildLambda(Pos_, Y("row"), many ? Y("Unwrap", Expr_) : Expr_),
-            BinSize_, Minimum_, Maximum_);
+                 BuildLambda(Pos_, Y("row"), many ? Y("Unwrap", Expr_) : Expr_),
+                 BinSize_, Minimum_, Maximum_);
     }
 
     void AddFactoryArguments(TNodePtr& apply) const final {
@@ -727,12 +734,13 @@ TAggregationPtr BuildLinearHistogramFactoryAggregation(TPosition pos, const TStr
     return new TLinearHistogramAggregationFactory(pos, name, factory, aggMode);
 }
 
-class TPercentileFactory final : public TAggregationFactory {
+class TPercentileFactory final: public TAggregationFactory {
 public:
     TPercentileFactory(TPosition pos, const TString& name, const TString& factory, EAggregateMode aggMode)
         : TAggregationFactory(pos, name, factory, aggMode)
         , FakeSource_(BuildFakeSource(pos))
-    {}
+    {
+    }
 
 private:
     TMaybe<TString> GetGenericKey() const final {
@@ -758,9 +766,9 @@ private:
 
     bool InitAggr(TContext& ctx, bool isFactory, ISource* src, TAstListNode& node, const TVector<TNodePtr>& exprs) final {
         ui32 adjustArgsCount = isFactory ? 0 : 1;
-        if (exprs.size() < 0 + adjustArgsCount  || exprs.size() > 1 + adjustArgsCount) {
+        if (exprs.size() < 0 + adjustArgsCount || exprs.size() > 1 + adjustArgsCount) {
             ctx.Error(Pos_) << "Aggregation function " << (isFactory ? "factory " : "") << Name_ << " requires "
-                << (0 + adjustArgsCount) << " or " << (1 + adjustArgsCount) << " arguments, given: " << exprs.size();
+                            << (0 + adjustArgsCount) << " or " << (1 + adjustArgsCount) << " arguments, given: " << exprs.size();
             return false;
         }
 
@@ -777,8 +785,9 @@ private:
             }
         }
 
-        if (!TAggregationFactory::InitAggr(ctx, isFactory, src, node, isFactory ? TVector<TNodePtr>() : TVector<TNodePtr>(1, exprs.front())))
+        if (!TAggregationFactory::InitAggr(ctx, isFactory, src, node, isFactory ? TVector<TNodePtr>() : TVector<TNodePtr>(1, exprs.front()))) {
             return false;
+        }
 
         TNodePtr x;
         if (1 + adjustArgsCount == exprs.size()) {
@@ -824,15 +833,17 @@ private:
     }
 
     std::pair<TNodePtr, bool> AggregationTraits(const TNodePtr& type, bool overState, bool many, bool allowAggApply, TContext& ctx) const final {
-        if (Percentiles_.empty())
-            return { TNodePtr(), true };
+        if (Percentiles_.empty()) {
+            return {TNodePtr(), true};
+        }
 
         TNodePtr names(Q(Percentiles_.cbegin()->first));
 
         if (Percentiles_.size() > 1U) {
             names = Y();
-            for (const auto& percentile : Percentiles_)
+            for (const auto& percentile : Percentiles_) {
                 names = L(names, Q(percentile.first));
+            }
             names = Q(names);
         }
 
@@ -840,17 +851,15 @@ private:
         const auto listType = distinct ? Y("ListType", Y("StructMemberType", Y("ListItemType", type), BuildQuotedAtom(Pos_, DistinctKey_))) : type;
         auto apply = GetApply(listType, many, allowAggApply, ctx);
         if (!apply) {
-            return { TNodePtr(), false };
+            return {TNodePtr(), false};
         }
 
         auto wrapped = WrapIfOverState(apply, overState, many, ctx);
         if (!wrapped) {
-            return { TNodePtr(), false };
+            return {TNodePtr(), false};
         }
 
-        return { distinct ?
-            Q(Y(names, wrapped, BuildQuotedAtom(Pos_, DistinctKey_))) :
-            Q(Y(names, wrapped)), true };
+        return {distinct ? Q(Y(names, wrapped, BuildQuotedAtom(Pos_, DistinctKey_))) : Q(Y(names, wrapped)), true};
     }
 
     bool DoInit(TContext& ctx, ISource* src) final {
@@ -874,16 +883,16 @@ TAggregationPtr BuildPercentileFactoryAggregation(TPosition pos, const TString&
     return new TPercentileFactory(pos, name, factory, aggMode);
 }
 
-class TTopFreqFactory final : public TAggregationFactory {
+class TTopFreqFactory final: public TAggregationFactory {
 public:
     TTopFreqFactory(TPosition pos, const TString& name, const TString& factory, EAggregateMode aggMode)
         : TAggregationFactory(pos, name, factory, aggMode)
         , FakeSource_(BuildFakeSource(pos))
-    {}
+    {
+    }
 
 private:
-
-    //first - n, second - buffer
+    // first - n, second - buffer
     using TPair = std::pair<TNodePtr, TNodePtr>;
 
     bool InitAggr(TContext& ctx, bool isFactory, ISource* src, TAstListNode& node, const TVector<TNodePtr>& exprs) final {
@@ -892,13 +901,13 @@ private:
         const ui32 MinBuffer = 100;
 
         if (exprs.size() < adjustArgsCount || exprs.size() > 2 + adjustArgsCount) {
-            ctx.Error(Pos_) << "Aggregation function " << (isFactory? "factory " : "") << Name_ <<
-                " requires " << adjustArgsCount << " to " << (2 + adjustArgsCount)  << " arguments, given: " << exprs.size();
+            ctx.Error(Pos_) << "Aggregation function " << (isFactory ? "factory " : "") << Name_ << " requires " << adjustArgsCount << " to " << (2 + adjustArgsCount) << " arguments, given: " << exprs.size();
             return false;
         }
 
-        if (!TAggregationFactory::InitAggr(ctx, isFactory, src, node, isFactory ? TVector<TNodePtr>() : TVector<TNodePtr>(1, exprs.front())))
+        if (!TAggregationFactory::InitAggr(ctx, isFactory, src, node, isFactory ? TVector<TNodePtr>() : TVector<TNodePtr>(1, exprs.front()))) {
             return false;
+        }
 
         TNodePtr n = Y("Null");
         TNodePtr buffer = Y("Null");
@@ -925,7 +934,7 @@ private:
         buffer = Y("Coalesce", buffer, Y("Uint32", Q(ToString(MinBuffer))));
         buffer = Y("Max", buffer, Y("Uint32", Q(ToString(MinBuffer))));
 
-        auto x = TPair{ n, buffer };
+        auto x = TPair{n, buffer};
         if (isFactory) {
             TopFreqFactoryParams_ = x;
         } else {
@@ -945,11 +954,11 @@ private:
         TPair topFreqs(TopFreqs_.cbegin()->second);
 
         if (TopFreqs_.size() > 1U) {
-            topFreqs = { Y(), Y() };
+            topFreqs = {Y(), Y()};
             for (const auto& topFreq : TopFreqs_) {
-                topFreqs = { L(topFreqs.first, topFreq.second.first), L(topFreqs.second, topFreq.second.second) };
+                topFreqs = {L(topFreqs.first, topFreq.second.first), L(topFreqs.second, topFreq.second.second)};
             }
-            topFreqs = { Q(topFreqs.first), Q(topFreqs.second) };
+            topFreqs = {Q(topFreqs.first), Q(topFreqs.second)};
         }
 
         auto apply = Y("Apply", Factory_, type, BuildLambda(Pos_, Y("row"), many ? Y("Unwrap", Expr_) : Expr_), topFreqs.first, topFreqs.second);
@@ -961,15 +970,17 @@ private:
     }
 
     std::pair<TNodePtr, bool> AggregationTraits(const TNodePtr& type, bool overState, bool many, bool allowAggApply, TContext& ctx) const final {
-        if (TopFreqs_.empty())
-            return { TNodePtr(), true };
+        if (TopFreqs_.empty()) {
+            return {TNodePtr(), true};
+        }
 
         TNodePtr names(Q(TopFreqs_.cbegin()->first));
 
         if (TopFreqs_.size() > 1U) {
             names = Y();
-            for (const auto& topFreq : TopFreqs_)
+            for (const auto& topFreq : TopFreqs_) {
                 names = L(names, Q(topFreq.first));
+            }
             names = Q(names);
         }
 
@@ -977,17 +988,15 @@ private:
         const auto listType = distinct ? Y("ListType", Y("StructMemberType", Y("ListItemType", type), BuildQuotedAtom(Pos_, DistinctKey_))) : type;
         auto apply = GetApply(listType, many, allowAggApply, ctx);
         if (!apply) {
-            return { nullptr, false };
+            return {nullptr, false};
         }
 
         auto wrapped = WrapIfOverState(apply, overState, many, ctx);
         if (!wrapped) {
-            return { nullptr, false };
+            return {nullptr, false};
         }
 
-        return { distinct ?
-            Q(Y(names, wrapped, BuildQuotedAtom(Pos_, DistinctKey_))) :
-            Q(Y(names, wrapped)), true };
+        return {distinct ? Q(Y(names, wrapped, BuildQuotedAtom(Pos_, DistinctKey_))) : Q(Y(names, wrapped)), true};
     }
 
     bool DoInit(TContext& ctx, ISource* src) final {
@@ -1014,19 +1023,20 @@ TAggregationPtr BuildTopFreqFactoryAggregation(TPosition pos, const TString& nam
 }
 
 template <bool HasKey>
-class TTopAggregationFactory final : public TAggregationFactory {
+class TTopAggregationFactory final: public TAggregationFactory {
 public:
     TTopAggregationFactory(TPosition pos, const TString& name, const TString& factory, EAggregateMode aggMode)
         : TAggregationFactory(pos, name, factory, aggMode)
         , FakeSource_(BuildFakeSource(pos))
-    {}
+    {
+    }
 
 private:
     bool InitAggr(TContext& ctx, bool isFactory, ISource* src, TAstListNode& node, const TVector<TNodePtr>& exprs) final {
         ui32 adjustArgsCount = isFactory ? 1 : (HasKey ? 3 : 2);
         if (exprs.size() != adjustArgsCount) {
             ctx.Error(Pos_) << "Aggregation function " << (isFactory ? "factory " : "") << Name_ << " requires "
-                << adjustArgsCount << " arguments, given: " << exprs.size();
+                            << adjustArgsCount << " arguments, given: " << exprs.size();
             return false;
         }
 
@@ -1071,8 +1081,8 @@ private:
         TNodePtr apply;
         if (HasKey) {
             apply = Y("Apply", Factory_, type,
-                BuildLambda(Pos_, Y("row"), many ? Y("Unwrap", Key_) : Key_),
-                BuildLambda(Pos_, Y("row"), many ? Y("Payload", Payload_) : Payload_));
+                      BuildLambda(Pos_, Y("row"), many ? Y("Unwrap", Key_) : Key_),
+                      BuildLambda(Pos_, Y("row"), many ? Y("Payload", Payload_) : Payload_));
         } else {
             apply = Y("Apply", Factory_, type, BuildLambda(Pos_, Y("row"), many ? Y("Unwrap", Payload_) : Payload_));
         }
@@ -1128,20 +1138,22 @@ TAggregationPtr BuildTopFactoryAggregation(TPosition pos, const TString& name, c
 }
 
 template TAggregationPtr BuildTopFactoryAggregation<false>(TPosition pos, const TString& name, const TString& factory, EAggregateMode aggMode);
-template TAggregationPtr BuildTopFactoryAggregation<true >(TPosition pos, const TString& name, const TString& factory, EAggregateMode aggMode);
+template TAggregationPtr BuildTopFactoryAggregation<true>(TPosition pos, const TString& name, const TString& factory, EAggregateMode aggMode);
 
-class TCountDistinctEstimateAggregationFactory final : public TAggregationFactory {
+class TCountDistinctEstimateAggregationFactory final: public TAggregationFactory {
 public:
     TCountDistinctEstimateAggregationFactory(TPosition pos, const TString& name, const TString& factory, EAggregateMode aggMode)
         : TAggregationFactory(pos, name, factory, aggMode)
-    {}
+    {
+    }
 
 private:
     bool InitAggr(TContext& ctx, bool isFactory, ISource* src, TAstListNode& node, const TVector<TNodePtr>& exprs) final {
         ui32 adjustArgsCount = isFactory ? 0 : 1;
         if (exprs.size() < adjustArgsCount || exprs.size() > 1 + adjustArgsCount) {
-            ctx.Error(Pos_) << Name_ << " aggregation function " << (isFactory ? "factory " : "") << " requires " <<
-                adjustArgsCount << " or " << (1 + adjustArgsCount) << " argument(s), given: " << exprs.size();
+            ctx.Error(Pos_) << Name_ << " aggregation function " << (isFactory ? "factory " : "")
+                            << " requires " << adjustArgsCount << " or " << (1 + adjustArgsCount)
+                            << " argument(s), given: " << exprs.size();
             return false;
         }
 
@@ -1201,7 +1213,7 @@ TAggregationPtr BuildCountDistinctEstimateFactoryAggregation(TPosition pos, cons
     return new TCountDistinctEstimateAggregationFactory(pos, name, factory, aggMode);
 }
 
-class TListAggregationFactory final : public TAggregationFactory {
+class TListAggregationFactory final: public TAggregationFactory {
 public:
     TListAggregationFactory(TPosition pos, const TString& name, const TString& factory, EAggregateMode aggMode)
         : TAggregationFactory(pos, name, factory, aggMode)
@@ -1216,7 +1228,7 @@ private:
         ui32 maxArgs = (1 + adjustArgsCount);
         if (exprs.size() < minArgs || exprs.size() > maxArgs) {
             ctx.Error(Pos_) << "List aggregation " << (isFactory ? "factory " : "") << "function require " << minArgs
-                << " or " << maxArgs << " arguments, given: " << exprs.size();
+                            << " or " << maxArgs << " arguments, given: " << exprs.size();
             return false;
         }
 
@@ -1281,26 +1293,26 @@ TAggregationPtr BuildListFactoryAggregation(TPosition pos, const TString& name,
     return new TListAggregationFactory(pos, name, factory, aggMode);
 }
 
-class TUserDefinedAggregationFactory final : public TAggregationFactory {
+class TUserDefinedAggregationFactory final: public TAggregationFactory {
 public:
     TUserDefinedAggregationFactory(TPosition pos, const TString& name, const TString& factory, EAggregateMode aggMode)
         : TAggregationFactory(pos, name, factory, aggMode)
-    {}
+    {
+    }
 
 private:
     bool InitAggr(TContext& ctx, bool isFactory, ISource* src, TAstListNode& node, const TVector<TNodePtr>& exprs) final {
         ui32 adjustArgsCount = isFactory ? 0 : 1;
         if (exprs.size() < (3 + adjustArgsCount) || exprs.size() > (7 + adjustArgsCount)) {
-            ctx.Error(Pos_) << "User defined aggregation function " << (isFactory ? "factory " : "") << " requires " <<
-                (3 + adjustArgsCount) << " to " << (7 + adjustArgsCount) << " arguments, given: " << exprs.size();
+            ctx.Error(Pos_) << "User defined aggregation function " << (isFactory ? "factory " : "") << " requires " << (3 + adjustArgsCount) << " to " << (7 + adjustArgsCount) << " arguments, given: " << exprs.size();
             return false;
         }
 
         Lambdas_[0] = BuildLambda(Pos_, Y("value", "parent"), Y("NamedApply", exprs[adjustArgsCount], Q(Y("value")), Y("AsStruct"), Y("DependsOn", "parent")));
         Lambdas_[1] = BuildLambda(Pos_, Y("value", "state", "parent"), Y("NamedApply", exprs[adjustArgsCount + 1], Q(Y("state", "value")), Y("AsStruct"), Y("DependsOn", "parent")));
         Lambdas_[2] = BuildLambda(Pos_, Y("one", "two"), Y("IfType", exprs[adjustArgsCount + 2], Y("NullType"),
-            BuildLambda(Pos_, Y(), Y("Void")),
-            BuildLambda(Pos_, Y(), Y("Apply", exprs[adjustArgsCount + 2], "one", "two"))));
+                                                           BuildLambda(Pos_, Y(), Y("Void")),
+                                                           BuildLambda(Pos_, Y(), Y("Apply", exprs[adjustArgsCount + 2], "one", "two"))));
 
         for (size_t i = 3U; i < Lambdas_.size(); ++i) {
             const auto j = adjustArgsCount + i;
@@ -1349,11 +1361,12 @@ TAggregationPtr BuildUserDefinedFactoryAggregation(TPosition pos, const TString&
     return new TUserDefinedAggregationFactory(pos, name, factory, aggMode);
 }
 
-class TCountAggregation final : public TAggregationFactory {
+class TCountAggregation final: public TAggregationFactory {
 public:
     TCountAggregation(TPosition pos, const TString& name, const TString& func, EAggregateMode aggMode)
         : TAggregationFactory(pos, name, func, aggMode)
-    {}
+    {
+    }
 
 private:
     TNodePtr DoClone() const final {
@@ -1380,19 +1393,20 @@ TAggregationPtr BuildCountAggregation(TPosition pos, const TString& name, const
     return new TCountAggregation(pos, name, func, aggMode);
 }
 
-class TPGFactoryAggregation final : public TAggregationFactory {
+class TPGFactoryAggregation final: public TAggregationFactory {
 public:
     TPGFactoryAggregation(TPosition pos, const TString& name, EAggregateMode aggMode)
         : TAggregationFactory(pos, name, "", aggMode, false, false)
         , PgFunc_(Name_)
-    {}
+    {
+    }
 
     bool InitAggr(TContext& ctx, bool isFactory, ISource* src, TAstListNode& node, const TVector<TNodePtr>& exprs) override {
         auto ret = TAggregationFactory::InitAggr(ctx, isFactory, src, node, exprs);
         if (ret) {
             if (isFactory) {
                 Factory_ = BuildLambda(Pos_, Y("type", "extractor"), Y(AggMode_ == EAggregateMode::OverWindow ? "PgWindowTraitsTuple" : "PgAggregationTraitsTuple",
-                    Q(PgFunc_), Y("ListItemType", "type"), "extractor"));
+                                                                       Q(PgFunc_), Y("ListItemType", "type"), "extractor"));
             } else {
                 Lambda_ = BuildLambda(Pos_, Y("row"), exprs);
             }
@@ -1413,11 +1427,11 @@ public:
         Y_UNUSED(allowAggApply);
         if (ShouldEmitAggApply(ctx) && allowAggApply && AggMode_ != EAggregateMode::OverWindow) {
             return Y("AggApply",
-                Q("pg_" + to_lower(PgFunc_)), Y("ListItemType", type), Lambda_);
+                     Q("pg_" + to_lower(PgFunc_)), Y("ListItemType", type), Lambda_);
         }
 
         return Y(AggMode_ == EAggregateMode::OverWindow ? "PgWindowTraits" : "PgAggregationTraits",
-            Q(PgFunc_), Y("ListItemType", type), Lambda_);
+                 Q(PgFunc_), Y("ListItemType", type), Lambda_);
     }
 
 private:
@@ -1433,7 +1447,7 @@ TAggregationPtr BuildPGFactoryAggregation(TPosition pos, const TString& name, EA
     return new TPGFactoryAggregation(pos, name, aggMode);
 }
 
-class TNthValueFactoryAggregation final : public TAggregationFactory {
+class TNthValueFactoryAggregation final: public TAggregationFactory {
 public:
 public:
     TNthValueFactoryAggregation(TPosition pos, const TString& name, const TString& factory, EAggregateMode aggMode)
@@ -1448,7 +1462,7 @@ private:
         ui32 expectedArgs = (1 + adjustArgsCount);
         if (exprs.size() != expectedArgs) {
             ctx.Error(Pos_) << "NthValue aggregation " << (isFactory ? "factory " : "") << "function require "
-                << expectedArgs << " arguments, given: " << exprs.size();
+                            << expectedArgs << " arguments, given: " << exprs.size();
             return false;
         }