YQL-20086 minikql

commit_hash:e96f7390db5fcbe7e9f64f898141a263ad522daa

1 files changed, 111 insertions, 111 deletions

diff --git a/yql/essentials/minikql/comp_nodes/mkql_block_agg_sum.cpp b/yql/essentials/minikql/comp_nodes/mkql_block_agg_sum.cpp
index 9598c56587a..bd91037f419 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_block_agg_sum.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_block_agg_sum.cpp
@@ -19,28 +19,28 @@ namespace NMiniKQL {
 
 namespace {
 
-template<bool IsNullable, typename TSum>
+template <bool IsNullable, typename TSum>
 struct TSumState;
 
-template<typename TSum>
+template <typename TSum>
 struct TSumState<true, TSum> {
     typename TPrimitiveDataType<TSum>::TArithmetic Sum_ = 0;
     ui8 IsValid_ = 0;
 };
 
-template<typename TSum>
+template <typename TSum>
 struct TSumState<false, TSum> {
     typename TPrimitiveDataType<TSum>::TArithmetic Sum_ = 0;
 };
 
-template<typename TOut>
+template <typename TOut>
 struct TAvgState {
     typename TPrimitiveDataType<TOut>::TArithmetic Sum_ = 0;
     ui64 Count_ = 0;
 };
 
 template <bool IsNullable, typename TSum>
-class TSumColumnBuilder : public IAggColumnBuilder {
+class TSumColumnBuilder: public IAggColumnBuilder {
 public:
     using TStateType = TSumState<IsNullable, TSum>;
 
@@ -70,20 +70,20 @@ private:
     TComputationContext& Ctx_;
 };
 
-template<typename TOut>
-class TAvgStateColumnBuilder : public IAggColumnBuilder {
+template <typename TOut>
+class TAvgStateColumnBuilder: public IAggColumnBuilder {
 public:
     TAvgStateColumnBuilder(ui64 size, TType* outputType, TComputationContext& ctx)
         : Ctx_(ctx)
         , Builder_(MakeArrayBuilder(TTypeInfoHelper(), outputType, ctx.ArrowMemoryPool, size, &ctx.Builder->GetPgBuilder()))
-{
+    {
     }
 
     void Add(const void* state) final {
         auto typedState = MakeStateWrapper<TAvgState<TOut>>(state);
         auto tupleBuilder = static_cast<NUdf::TTupleArrayBuilder<true>*>(Builder_.get());
         if (typedState->Count_) {
-            TBlockItem tupleItems[] = { TBlockItem(TOut(typedState->Sum_)), TBlockItem(typedState->Count_)} ;
+            TBlockItem tupleItems[] = {TBlockItem(TOut(typedState->Sum_)), TBlockItem(typedState->Count_)};
             tupleBuilder->Add(TBlockItem(tupleItems));
         } else {
             tupleBuilder->Add(TBlockItem());
@@ -99,8 +99,8 @@ private:
     const std::unique_ptr<IArrayBuilder> Builder_;
 };
 
-template<typename TOut>
-class TAvgResultColumnBuilder : public IAggColumnBuilder {
+template <typename TOut>
+class TAvgResultColumnBuilder: public IAggColumnBuilder {
 public:
     TAvgResultColumnBuilder(ui64 size, TComputationContext& ctx)
         : Ctx_(ctx)
@@ -133,7 +133,7 @@ template <typename TTag, typename TIn, typename TOut>
 class TAvgBlockAggregator;
 
 template <bool IsNullable, bool IsScalar, typename TIn, typename TSum>
-class TSumBlockAggregator<TCombineAllTag, IsNullable, IsScalar, TIn, TSum> : public TCombineAllTag::TBase {
+class TSumBlockAggregator<TCombineAllTag, IsNullable, IsScalar, TIn, TSum>: public TCombineAllTag::TBase {
 public:
     using TBase = TCombineAllTag::TBase;
     using TStateType = TSumState<IsNullable, TSum>;
@@ -279,7 +279,7 @@ void PushValueToState(TSumState<IsNullable, TSum>* typedState, const arrow::Datu
 }
 
 template <bool IsNullable, bool IsScalar, typename TIn, typename TSum>
-class TSumBlockAggregator<TCombineKeysTag, IsNullable, IsScalar, TIn, TSum> : public TCombineKeysTag::TBase {
+class TSumBlockAggregator<TCombineKeysTag, IsNullable, IsScalar, TIn, TSum>: public TCombineKeysTag::TBase {
 public:
     using TBase = TCombineKeysTag::TBase;
     using TStateType = TSumState<IsNullable, TSum>;
@@ -319,7 +319,7 @@ private:
 };
 
 template <bool IsNullable, bool IsScalar, typename TIn, typename TSum>
-class TSumBlockAggregator<TFinalizeKeysTag, IsNullable, IsScalar, TIn, TSum> : public TFinalizeKeysTag::TBase {
+class TSumBlockAggregator<TFinalizeKeysTag, IsNullable, IsScalar, TIn, TSum>: public TFinalizeKeysTag::TBase {
 public:
     using TBase = TFinalizeKeysTag::TBase;
     using TStateType = TSumState<IsNullable, TSum>;
@@ -375,7 +375,9 @@ public:
 
         if constexpr (IsNullable) {
             buffer.PopNumber(deserializedState.IsValid_);
-            if (!deserializedState.IsValid_) return;
+            if (!deserializedState.IsValid_) {
+                return;
+            }
 
             typedState->IsValid_ = 1;
         }
@@ -392,8 +394,8 @@ private:
     TType* const DataType_;
 };
 
-template<typename TIn, typename TOut>
-class TAvgBlockAggregator<TCombineAllTag, TIn, TOut> : public TCombineAllTag::TBase {
+template <typename TIn, typename TOut>
+class TAvgBlockAggregator<TCombineAllTag, TIn, TOut>: public TCombineAllTag::TBase {
 public:
     using TBase = TCombineAllTag::TBase;
     using TInScalar = typename TPrimitiveDataType<TIn>::TScalarResult;
@@ -498,7 +500,7 @@ private:
 };
 
 template <typename TIn, typename TOut>
-class TAvgBlockAggregator<TCombineKeysTag, TIn, TOut> : public TCombineKeysTag::TBase {
+class TAvgBlockAggregator<TCombineKeysTag, TIn, TOut>: public TCombineKeysTag::TBase {
 public:
     using TBase = TCombineKeysTag::TBase;
     using TInScalar = typename TPrimitiveDataType<TIn>::TScalarResult;
@@ -555,8 +557,8 @@ private:
     TType* const OutputType_;
 };
 
-template<typename TOut>
-class TAvgBlockAggregatorOverState : public TFinalizeKeysTag::TBase {
+template <typename TOut>
+class TAvgBlockAggregatorOverState: public TFinalizeKeysTag::TBase {
 public:
     using TBase = TFinalizeKeysTag::TBase;
     using TInScalar = typename TPrimitiveDataType<TOut>::TScalarResult;
@@ -639,7 +641,7 @@ private:
 };
 
 template <typename TTag, bool IsNullable, bool IsScalar, typename TIn, typename TSum>
-class TPreparedSumBlockAggregator : public TTag::TPreparedAggregator {
+class TPreparedSumBlockAggregator: public TTag::TPreparedAggregator {
 public:
     using TBase = typename TTag::TPreparedAggregator;
     using TStateType = TSumState<IsNullable, TSum>;
@@ -649,7 +651,8 @@ public:
         , FilterColumn_(filterColumn)
         , ArgColumn_(argColumn)
         , DataType_(dataType)
-    {}
+    {
+    }
 
     std::unique_ptr<typename TTag::TAggregator> Make(TComputationContext& ctx) const final {
         return std::make_unique<TSumBlockAggregator<TTag, IsNullable, IsScalar, TIn, TSum>>(FilterColumn_, ArgColumn_, DataType_, ctx);
@@ -661,7 +664,7 @@ private:
     TType* const DataType_;
 };
 
-template<typename TTag, typename TIn, typename TSum>
+template <typename TTag, typename TIn, typename TSum>
 std::unique_ptr<typename TTag::TPreparedAggregator> PrepareSumFixed(TType* type, bool isOptional, bool isScalar, std::optional<ui32> filterColumn, ui32 argColumn) {
     if (isScalar) {
         if (isOptional) {
@@ -683,7 +686,6 @@ std::unique_ptr<typename TTag::TPreparedAggregator> PrepareSum(TTupleType* tuple
     auto dataType = UnpackOptionalData(argType, isOptional);
     bool isScalar = blockType->GetShape() == TBlockType::EShape::Scalar;
 
-
     TType* sumRetType = nullptr;
     const auto& typeInfo = NYql::NUdf::GetDataTypeInfo(*dataType->GetDataSlot());
     if (typeInfo.Features & NYql::NUdf::EDataTypeFeatures::SignedIntegralType) {
@@ -702,53 +704,50 @@ std::unique_ptr<typename TTag::TPreparedAggregator> PrepareSum(TTupleType* tuple
     }
     sumRetType = TOptionalType::Create(sumRetType, env);
 
-
     switch (*dataType->GetDataSlot()) {
-    case NUdf::EDataSlot::Int8:
-        return PrepareSumFixed<TTag, i8, i64>(sumRetType, isOptional, isScalar, filterColumn, argColumn);
-    case NUdf::EDataSlot::Uint8:
-        return PrepareSumFixed<TTag, ui8, ui64>(sumRetType, isOptional, isScalar, filterColumn, argColumn);
-    case NUdf::EDataSlot::Int16:
-        return PrepareSumFixed<TTag, i16, i64>(sumRetType, isOptional, isScalar, filterColumn, argColumn);
-    case NUdf::EDataSlot::Uint16:
-        return PrepareSumFixed<TTag, ui16, ui64>(sumRetType, isOptional, isScalar, filterColumn, argColumn);
-    case NUdf::EDataSlot::Int32:
-        return PrepareSumFixed<TTag, i32, i64>(sumRetType, isOptional, isScalar, filterColumn, argColumn);
-    case NUdf::EDataSlot::Uint32:
-        return PrepareSumFixed<TTag, ui32, ui64>(sumRetType, isOptional, isScalar, filterColumn, argColumn);
-    case NUdf::EDataSlot::Int64:
-        return PrepareSumFixed<TTag, i64, i64>(sumRetType, isOptional, isScalar, filterColumn, argColumn);
-    case NUdf::EDataSlot::Uint64:
-        return PrepareSumFixed<TTag, ui64, ui64>(sumRetType, isOptional, isScalar, filterColumn, argColumn);
-    case NUdf::EDataSlot::Float:
-        return PrepareSumFixed<TTag, float, float>(sumRetType, isOptional, isScalar, filterColumn, argColumn);
-    case NUdf::EDataSlot::Double:
-        return PrepareSumFixed<TTag, double, double>(sumRetType, isOptional, isScalar, filterColumn, argColumn);
-    case NUdf::EDataSlot::Interval:
-        return PrepareSumFixed<TTag, i64, NYql::NDecimal::TInt128>(sumRetType, isOptional, isScalar, filterColumn, argColumn);
-    case NUdf::EDataSlot::Decimal:
-        return PrepareSumFixed<TTag, NYql::NDecimal::TInt128, NYql::NDecimal::TInt128>(sumRetType, isOptional, isScalar, filterColumn, argColumn);
-    default:
-        throw yexception() << "Unsupported SUM input type";
+        case NUdf::EDataSlot::Int8:
+            return PrepareSumFixed<TTag, i8, i64>(sumRetType, isOptional, isScalar, filterColumn, argColumn);
+        case NUdf::EDataSlot::Uint8:
+            return PrepareSumFixed<TTag, ui8, ui64>(sumRetType, isOptional, isScalar, filterColumn, argColumn);
+        case NUdf::EDataSlot::Int16:
+            return PrepareSumFixed<TTag, i16, i64>(sumRetType, isOptional, isScalar, filterColumn, argColumn);
+        case NUdf::EDataSlot::Uint16:
+            return PrepareSumFixed<TTag, ui16, ui64>(sumRetType, isOptional, isScalar, filterColumn, argColumn);
+        case NUdf::EDataSlot::Int32:
+            return PrepareSumFixed<TTag, i32, i64>(sumRetType, isOptional, isScalar, filterColumn, argColumn);
+        case NUdf::EDataSlot::Uint32:
+            return PrepareSumFixed<TTag, ui32, ui64>(sumRetType, isOptional, isScalar, filterColumn, argColumn);
+        case NUdf::EDataSlot::Int64:
+            return PrepareSumFixed<TTag, i64, i64>(sumRetType, isOptional, isScalar, filterColumn, argColumn);
+        case NUdf::EDataSlot::Uint64:
+            return PrepareSumFixed<TTag, ui64, ui64>(sumRetType, isOptional, isScalar, filterColumn, argColumn);
+        case NUdf::EDataSlot::Float:
+            return PrepareSumFixed<TTag, float, float>(sumRetType, isOptional, isScalar, filterColumn, argColumn);
+        case NUdf::EDataSlot::Double:
+            return PrepareSumFixed<TTag, double, double>(sumRetType, isOptional, isScalar, filterColumn, argColumn);
+        case NUdf::EDataSlot::Interval:
+            return PrepareSumFixed<TTag, i64, NYql::NDecimal::TInt128>(sumRetType, isOptional, isScalar, filterColumn, argColumn);
+        case NUdf::EDataSlot::Decimal:
+            return PrepareSumFixed<TTag, NYql::NDecimal::TInt128, NYql::NDecimal::TInt128>(sumRetType, isOptional, isScalar, filterColumn, argColumn);
+        default:
+            throw yexception() << "Unsupported SUM input type";
     }
 }
 
-class TBlockSumFactory : public IBlockAggregatorFactory {
+class TBlockSumFactory: public IBlockAggregatorFactory {
 public:
     std::unique_ptr<TCombineAllTag::TPreparedAggregator> PrepareCombineAll(
         TTupleType* tupleType,
         std::optional<ui32> filterColumn,
         const std::vector<ui32>& argsColumns,
-        const TTypeEnvironment& env) const final
-    {
+        const TTypeEnvironment& env) const final {
         return PrepareSum<TCombineAllTag>(tupleType, filterColumn, argsColumns[0], env);
     }
 
     std::unique_ptr<TCombineKeysTag::TPreparedAggregator> PrepareCombineKeys(
         TTupleType* tupleType,
         const std::vector<ui32>& argsColumns,
-        const TTypeEnvironment& env) const final
-    {
+        const TTypeEnvironment& env) const final {
         return PrepareSum<TCombineKeysTag>(tupleType, std::optional<ui32>(), argsColumns[0], env);
     }
 
@@ -757,8 +756,7 @@ public:
         const std::vector<ui32>& argsColumns,
         const TTypeEnvironment& env,
         TType* returnType,
-        ui32 hint) const final
-    {
+        ui32 hint) const final {
         Y_UNUSED(returnType);
         Y_UNUSED(hint);
         return PrepareSum<TFinalizeKeysTag>(tupleType, std::optional<ui32>(), argsColumns[0], env);
@@ -766,7 +764,7 @@ public:
 };
 
 template <typename TTag, typename TIn, typename TOut>
-class TPreparedAvgBlockAggregator : public TTag::TPreparedAggregator {
+class TPreparedAvgBlockAggregator: public TTag::TPreparedAggregator {
 public:
     using TBase = typename TTag::TPreparedAggregator;
 
@@ -775,7 +773,8 @@ public:
         , FilterColumn_(filterColumn)
         , ArgColumn_(argColumn)
         , OutputType_(outputType)
-    {}
+    {
+    }
 
     std::unique_ptr<typename TTag::TAggregator> Make(TComputationContext& ctx) const final {
         return std::make_unique<TAvgBlockAggregator<TTag, TIn, TOut>>(FilterColumn_, ArgColumn_, OutputType_, ctx);
@@ -787,15 +786,16 @@ private:
     TType* const OutputType_;
 };
 
-template<typename TOut>
-class TPreparedAvgBlockAggregatorOverState : public TFinalizeKeysTag::TPreparedAggregator {
+template <typename TOut>
+class TPreparedAvgBlockAggregatorOverState: public TFinalizeKeysTag::TPreparedAggregator {
 public:
     using TBase = TFinalizeKeysTag::TPreparedAggregator;
 
     TPreparedAvgBlockAggregatorOverState(ui32 argColumn)
         : TBase(sizeof(TAvgState<TOut>))
         , ArgColumn_(argColumn)
-    {}
+    {
+    }
 
     std::unique_ptr<typename TFinalizeKeysTag::TAggregator> Make(TComputationContext& ctx) const final {
         return std::make_unique<TAvgBlockAggregatorOverState<TOut>>(ArgColumn_, ctx);
@@ -812,49 +812,49 @@ template <typename TTag>
 std::unique_ptr<typename TTag::TPreparedAggregator> PrepareAvgOverInput(TTupleType* tupleType, std::optional<ui32> filterColumn, ui32 argColumn, const TTypeEnvironment& env) {
     auto doubleType = TDataType::Create(NUdf::TDataType<double>::Id, env);
     auto ui64Type = TDataType::Create(NUdf::TDataType<ui64>::Id, env);
-    TVector<TType*> tupleElements = { doubleType, ui64Type };
+    TVector<TType*> tupleElements = {doubleType, ui64Type};
     auto avgRetType = TOptionalType::Create(TTupleType::Create(2, tupleElements.data(), env), env);
 
     auto argType = AS_TYPE(TBlockType, tupleType->GetElementType(argColumn))->GetItemType();
     bool isOptional;
     auto dataType = UnpackOptionalData(argType, isOptional);
     switch (*dataType->GetDataSlot()) {
-    case NUdf::EDataSlot::Int8:
-        return std::make_unique<TPreparedAvgBlockAggregator<TTag, i8, double>>(filterColumn, argColumn, avgRetType);
-    case NUdf::EDataSlot::Uint8:
-    case NUdf::EDataSlot::Bool:
-        return std::make_unique<TPreparedAvgBlockAggregator<TTag, ui8, double>>(filterColumn, argColumn, avgRetType);
-    case NUdf::EDataSlot::Int16:
-        return std::make_unique<TPreparedAvgBlockAggregator<TTag, i16, double>>(filterColumn, argColumn, avgRetType);
-    case NUdf::EDataSlot::Uint16:
-        return std::make_unique<TPreparedAvgBlockAggregator<TTag, ui16, double>>(filterColumn, argColumn, avgRetType);
-    case NUdf::EDataSlot::Int32:
-        return std::make_unique<TPreparedAvgBlockAggregator<TTag, i32, double>>(filterColumn, argColumn, avgRetType);
-    case NUdf::EDataSlot::Uint32:
-        return std::make_unique<TPreparedAvgBlockAggregator<TTag, ui32, double>>(filterColumn, argColumn, avgRetType);
-    case NUdf::EDataSlot::Int64:
-        return std::make_unique<TPreparedAvgBlockAggregator<TTag, i64, double>>(filterColumn, argColumn, avgRetType);
-    case NUdf::EDataSlot::Uint64:
-        return std::make_unique<TPreparedAvgBlockAggregator<TTag, ui64, double>>(filterColumn, argColumn, avgRetType);
-    case NUdf::EDataSlot::Float:
-        return std::make_unique<TPreparedAvgBlockAggregator<TTag, float, double>>(filterColumn, argColumn, avgRetType);
-    case NUdf::EDataSlot::Double:
-        return std::make_unique<TPreparedAvgBlockAggregator<TTag, double, double>>(filterColumn, argColumn, avgRetType);
-    case NUdf::EDataSlot::Interval: {
-        auto decimalType = TDataDecimalType::Create(NYql::NDecimal::MaxPrecision, 0, env);
-        TVector<TType*> tupleDecimalElements = { decimalType, ui64Type };
-        auto avgRetDecimalType = TOptionalType::Create(TTupleType::Create(2, tupleDecimalElements.data(), env), env);
-        return std::make_unique<TPreparedAvgBlockAggregator<TTag, i64, NYql::NDecimal::TInt128>>(filterColumn, argColumn, avgRetDecimalType);
-    }
-    case NUdf::EDataSlot::Decimal: {
-        auto [precision, scale] = static_cast<TDataDecimalType*>(dataType)->GetParams();
-        auto decimalType = TDataDecimalType::Create(precision, scale, env);
-        TVector<TType*> tupleDecimalElements = { decimalType, ui64Type };
-        auto avgRetDecimalType = TOptionalType::Create(TTupleType::Create(2, tupleDecimalElements.data(), env), env);
-        return std::make_unique<TPreparedAvgBlockAggregator<TTag, NYql::NDecimal::TInt128, NYql::NDecimal::TInt128>>(filterColumn, argColumn, avgRetDecimalType);
-    }
-    default:
-        throw yexception() << "Unsupported AVG input type";
+        case NUdf::EDataSlot::Int8:
+            return std::make_unique<TPreparedAvgBlockAggregator<TTag, i8, double>>(filterColumn, argColumn, avgRetType);
+        case NUdf::EDataSlot::Uint8:
+        case NUdf::EDataSlot::Bool:
+            return std::make_unique<TPreparedAvgBlockAggregator<TTag, ui8, double>>(filterColumn, argColumn, avgRetType);
+        case NUdf::EDataSlot::Int16:
+            return std::make_unique<TPreparedAvgBlockAggregator<TTag, i16, double>>(filterColumn, argColumn, avgRetType);
+        case NUdf::EDataSlot::Uint16:
+            return std::make_unique<TPreparedAvgBlockAggregator<TTag, ui16, double>>(filterColumn, argColumn, avgRetType);
+        case NUdf::EDataSlot::Int32:
+            return std::make_unique<TPreparedAvgBlockAggregator<TTag, i32, double>>(filterColumn, argColumn, avgRetType);
+        case NUdf::EDataSlot::Uint32:
+            return std::make_unique<TPreparedAvgBlockAggregator<TTag, ui32, double>>(filterColumn, argColumn, avgRetType);
+        case NUdf::EDataSlot::Int64:
+            return std::make_unique<TPreparedAvgBlockAggregator<TTag, i64, double>>(filterColumn, argColumn, avgRetType);
+        case NUdf::EDataSlot::Uint64:
+            return std::make_unique<TPreparedAvgBlockAggregator<TTag, ui64, double>>(filterColumn, argColumn, avgRetType);
+        case NUdf::EDataSlot::Float:
+            return std::make_unique<TPreparedAvgBlockAggregator<TTag, float, double>>(filterColumn, argColumn, avgRetType);
+        case NUdf::EDataSlot::Double:
+            return std::make_unique<TPreparedAvgBlockAggregator<TTag, double, double>>(filterColumn, argColumn, avgRetType);
+        case NUdf::EDataSlot::Interval: {
+            auto decimalType = TDataDecimalType::Create(NYql::NDecimal::MaxPrecision, 0, env);
+            TVector<TType*> tupleDecimalElements = {decimalType, ui64Type};
+            auto avgRetDecimalType = TOptionalType::Create(TTupleType::Create(2, tupleDecimalElements.data(), env), env);
+            return std::make_unique<TPreparedAvgBlockAggregator<TTag, i64, NYql::NDecimal::TInt128>>(filterColumn, argColumn, avgRetDecimalType);
+        }
+        case NUdf::EDataSlot::Decimal: {
+            auto [precision, scale] = static_cast<TDataDecimalType*>(dataType)->GetParams();
+            auto decimalType = TDataDecimalType::Create(precision, scale, env);
+            TVector<TType*> tupleDecimalElements = {decimalType, ui64Type};
+            auto avgRetDecimalType = TOptionalType::Create(TTupleType::Create(2, tupleDecimalElements.data(), env), env);
+            return std::make_unique<TPreparedAvgBlockAggregator<TTag, NYql::NDecimal::TInt128, NYql::NDecimal::TInt128>>(filterColumn, argColumn, avgRetDecimalType);
+        }
+        default:
+            throw yexception() << "Unsupported AVG input type";
     }
 }
 
@@ -877,20 +877,20 @@ std::unique_ptr<typename TFinalizeKeysTag::TPreparedAggregator> PrepareAvg<TFina
     bool isOptional;
     auto aggTupleType = UnpackOptional(argType, isOptional);
     MKQL_ENSURE(aggTupleType->IsTuple(),
-        "Expected tuple or optional of tuple, actual: " << PrintNode(argType, true));
+                "Expected tuple or optional of tuple, actual: " << PrintNode(argType, true));
     auto dataType = UnpackOptionalData(AS_TYPE(TTupleType, aggTupleType)->GetElementType(0), isOptional);
 
     switch (*dataType->GetDataSlot()) {
-    case NUdf::EDataSlot::Decimal:
-        return std::make_unique<TPreparedAvgBlockAggregatorOverState<NYql::NDecimal::TInt128>>(argColumn);
-    case NUdf::EDataSlot::Double:
-        return std::make_unique<TPreparedAvgBlockAggregatorOverState<double>>(argColumn);
-    default:
-        throw yexception() << "Unsupported Finalize input type";
+        case NUdf::EDataSlot::Decimal:
+            return std::make_unique<TPreparedAvgBlockAggregatorOverState<NYql::NDecimal::TInt128>>(argColumn);
+        case NUdf::EDataSlot::Double:
+            return std::make_unique<TPreparedAvgBlockAggregatorOverState<double>>(argColumn);
+        default:
+            throw yexception() << "Unsupported Finalize input type";
     }
 }
 
-class TBlockAvgFactory : public IBlockAggregatorFactory {
+class TBlockAvgFactory: public IBlockAggregatorFactory {
 public:
     std::unique_ptr<TCombineAllTag::TPreparedAggregator> PrepareCombineAll(
         TTupleType* tupleType,
@@ -919,7 +919,7 @@ public:
     }
 };
 
-}
+} // namespace
 
 std::unique_ptr<IBlockAggregatorFactory> MakeBlockSumFactory() {
     return std::make_unique<TBlockSumFactory>();
@@ -929,5 +929,5 @@ std::unique_ptr<IBlockAggregatorFactory> MakeBlockAvgFactory() {
     return std::make_unique<TBlockAvgFactory>();
 }
 
-}
-}
+} // namespace NMiniKQL
+} // namespace NKikimr