get rid of legacy block abi, preparation for arrow abi

10 files changed, 69 insertions, 529 deletions

diff --git a/ydb/library/yql/minikql/computation/mkql_computation_node_holders.cpp b/ydb/library/yql/minikql/computation/mkql_computation_node_holders.cpp
index 1c27ab1477..a546e94ded 100644
--- a/ydb/library/yql/minikql/computation/mkql_computation_node_holders.cpp
+++ b/ydb/library/yql/minikql/computation/mkql_computation_node_holders.cpp
@@ -442,116 +442,6 @@ private:
     const ui32 Size;
 };
 
-class TFlatDataBlockImpl : public TComputationValue<TFlatDataBlockImpl, NUdf::TFlatDataBlock> {
-public:
-    TFlatDataBlockImpl(TMemoryUsageInfo* memInfo, ui32 initialSize, ui32 initialCapacity)
-        : TComputationValue(memInfo)
-        , Buffer_(nullptr)
-        , Allocated_(0)
-    {
-        Grow(Max(initialCapacity, initialSize));
-        Size_ = initialSize;
-    }
-
-    NUdf::TBlock* AsBlock() override {
-        return this;
-    }
-
-    NUdf::TFlatDataBlock* AsFlatDataBlock() override {
-        return this;
-    }
-
-    bool VisitBlocks(NUdf::TBlockCallback callback, void* context) override {
-        return callback(*this, context);
-    }
-
-    void Grow(ui32 size) override {
-        ui32 newCapacity = Max(Size_ + size, Capacity_ * 2);
-        if (!newCapacity) {
-            return;
-        }
-
-        ui32 newAllocated = AlignUp(2 * MKQL_ALIGNMENT + newCapacity, MKQL_ALIGNMENT);
-        void* newBuffer = MKQLAllocWithSize(newAllocated);
-        MKQL_MEM_TAKE(GetMemInfo(), newBuffer, newAllocated);
-        void* newData = static_cast<char*>(newBuffer) + MKQL_ALIGNMENT;
-        memset(newBuffer, 0, MKQL_ALIGNMENT);
-        if (Buffer_) {
-            memcpy(newData, Data_, Size_);
-            MKQL_MEM_RETURN(GetMemInfo(), Buffer_, Allocated_);
-            MKQLFreeWithSize(Buffer_, Allocated_);
-        }
-
-        Capacity_ = newCapacity;
-        Allocated_ = newAllocated;
-        Data_ = newData;
-        Buffer_ = newBuffer;
-    }
-
-    ~TFlatDataBlockImpl()
-    {
-        if (Buffer_) {
-            MKQL_MEM_RETURN(GetMemInfo(), Buffer_, Allocated_);
-            MKQLFreeWithSize(Buffer_, Allocated_);
-        }
-    }
-
-private:
-    void* Buffer_; // Data_ has padding of 16 zero bytes before and at least 16 garbage bytes after
-    ui32 Allocated_; // Full size of Buffer_
-};
-
-class TFlatArrayBlockImpl : public TComputationValue<TFlatArrayBlockImpl, NUdf::TFlatArrayBlock> {
-public:
-    TFlatArrayBlockImpl(TMemoryUsageInfo* memInfo, ui32 count)
-        : TComputationValue(memInfo, count)
-    {
-        MKQL_MEM_TAKE(GetMemInfo(), Items(), Count() * sizeof(NUdf::TBlockPtr));
-    }
-
-    ~TFlatArrayBlockImpl() {
-        MKQL_MEM_RETURN(GetMemInfo(), Items(), Count() * sizeof(NUdf::TBlockPtr));
-    }
-
-    NUdf::TBlock* AsBlock() override {
-        return this;
-    }
-
-    NUdf::TFlatArrayBlock* AsFlatArrayBlock() override {
-        return this;
-    }
-
-    bool VisitBlocks(NUdf::TBlockCallback callback, void* context) override {
-        for (ui32 i = 0; i < Count(); ++i) {
-            if (!callback(*GetItem(i), context)) {
-                return false;
-            }
-        }
-
-        return callback(*this, context);
-    }
-};
-
-class TSingleBlockImpl : public TComputationValue<TSingleBlockImpl, NUdf::TSingleBlock> {
-public:
-    TSingleBlockImpl(TMemoryUsageInfo* memInfo, const NUdf::TUnboxedValue& value)
-        : TComputationValue(memInfo, value)
-    {
-    }
-
-    NUdf::TBlock* AsBlock() override {
-        return this;
-    }
-
-    NUdf::TSingleBlock* AsSingleBlock() override {
-        return this;
-    }
-
-    bool VisitBlocks(NUdf::TBlockCallback callback, void* context) override {
-        return callback(*this, context);
-    }
-};
-
 class TArrayNode: public TMutableCodegeneratorFallbackNode<TArrayNode> {
     typedef TMutableCodegeneratorFallbackNode<TArrayNode> TBaseComputation;
 public:
@@ -3058,18 +2948,6 @@ NUdf::TUnboxedValuePod THolderFactory::CreateDirectArrayHolder(ui32 size, NUdf::
     return res;
 }
 
-NUdf::TFlatDataBlockPtr THolderFactory::CreateFlatDataBlock(ui32 initialSize, ui32 initialCapacity) const {
-    return AllocateOn<TFlatDataBlockImpl>(CurrentAllocState, &MemInfo, initialSize, initialCapacity);
-}
-
-NUdf::TFlatArrayBlockPtr THolderFactory::CreateFlatArrayBlock(ui32 count) const {
-    return AllocateOn<TFlatArrayBlockImpl>(CurrentAllocState, &MemInfo, count);
-}
-
-NUdf::TSingleBlockPtr THolderFactory::CreateSingleBlock(const NUdf::TUnboxedValue& value) const {
-    return AllocateOn<TSingleBlockImpl>(CurrentAllocState, &MemInfo, value);
-}
-
 NUdf::TUnboxedValuePod THolderFactory::CreateArrowBlock(arrow::Datum&& datum) const {
     return Create<TArrowBlock>(std::move(datum));
 }
diff --git a/ydb/library/yql/minikql/computation/mkql_computation_node_holders.h b/ydb/library/yql/minikql/computation/mkql_computation_node_holders.h
index a7de267130..85681918c7 100644
--- a/ydb/library/yql/minikql/computation/mkql_computation_node_holders.h
+++ b/ydb/library/yql/minikql/computation/mkql_computation_node_holders.h
@@ -402,10 +402,6 @@ public:
 
     NUdf::TUnboxedValuePod CreateDirectArrayHolder(ui32 size, NUdf::TUnboxedValue*& itemsPtr) const;
 
-    NUdf::TFlatDataBlockPtr CreateFlatDataBlock(ui32 initialSize, ui32 initialCapacity) const;
-    NUdf::TFlatArrayBlockPtr CreateFlatArrayBlock(ui32 count) const;
-    NUdf::TSingleBlockPtr CreateSingleBlock(const NUdf::TUnboxedValue& value) const;
-
     NUdf::TUnboxedValuePod CreateArrowBlock(arrow::Datum&& datum) const;
 
     NUdf::TUnboxedValuePod VectorAsArray(TUnboxedValueVector& values) const;
diff --git a/ydb/library/yql/minikql/computation/mkql_computation_node_impl.h b/ydb/library/yql/minikql/computation/mkql_computation_node_impl.h
index 01d170cf11..9398284a99 100644
--- a/ydb/library/yql/minikql/computation/mkql_computation_node_impl.h
+++ b/ydb/library/yql/minikql/computation/mkql_computation_node_impl.h
@@ -991,31 +991,27 @@ private:
         return false;
     }
 
-    NUdf::TBlock* AsBlock() override {
-        return nullptr;
+    void Unused1() override {
+        ThrowNotSupported(__func__);
     }
 
-    NUdf::TFlatArrayBlock* AsFlatArrayBlock() override {
-        return nullptr;
+    void Unused2() override {
+        ThrowNotSupported(__func__);
     }
 
-    NUdf::TFlatDataBlock* AsFlatDataBlock() override {
-        return nullptr;
+    void Unused3() override {
+        ThrowNotSupported(__func__);
     }
 
-    NUdf::TSingleBlock* AsSingleBlock() override {
-        return nullptr;
+    void Unused4() override {
+        ThrowNotSupported(__func__);
     }
 
-    NUdf::EFetchStatus FetchBlock(NUdf::TUnboxedValue& result, ui32 rowsLimitHint) override {
-        Y_UNUSED(result);
-        Y_UNUSED(rowsLimitHint);
+    void Unused5() override {
         ThrowNotSupported(__func__);
     }
 
-    bool VisitBlocks(NUdf::TBlockCallback callback, void* context) override {
-        Y_UNUSED(callback);
-        Y_UNUSED(context);
+    void Unused6() override {
         ThrowNotSupported(__func__);
     }
 
diff --git a/ydb/library/yql/minikql/computation/mkql_value_builder.cpp b/ydb/library/yql/minikql/computation/mkql_value_builder.cpp
index 7561ef034e..5b6869a243 100644
--- a/ydb/library/yql/minikql/computation/mkql_value_builder.cpp
+++ b/ydb/library/yql/minikql/computation/mkql_value_builder.cpp
@@ -202,16 +202,16 @@ NUdf::TUnboxedValue TDefaultValueBuilder::Run(const NUdf::TSourcePosition& calle
     return ret;
 }
 
-NUdf::TFlatDataBlockPtr TDefaultValueBuilder::NewFlatDataBlock(ui32 initialSize, ui32 initialCapacity) const {
-    return HolderFactory_.CreateFlatDataBlock(initialSize, initialCapacity);
+void TDefaultValueBuilder::Unused1() const {
+    Y_FAIL("Not implemented");
 }
 
-NUdf::TFlatArrayBlockPtr TDefaultValueBuilder::NewFlatArrayBlock(ui32 count) const {
-    return HolderFactory_.CreateFlatArrayBlock(count);
+void TDefaultValueBuilder::Unused2() const {
+    Y_FAIL("Not implemented");
 }
 
-NUdf::TSingleBlockPtr TDefaultValueBuilder::NewSingleBlock(const NUdf::TUnboxedValue& value) const {
-    return HolderFactory_.CreateSingleBlock(value);
+void TDefaultValueBuilder::Unused3() const {
+    Y_FAIL("Not implemented");
 }
 
 bool TDefaultValueBuilder::FindTimezoneName(ui32 id, NUdf::TStringRef& name) const {
diff --git a/ydb/library/yql/minikql/computation/mkql_value_builder.h b/ydb/library/yql/minikql/computation/mkql_value_builder.h
index 0b8eeeb9de..dea2ef0205 100644
--- a/ydb/library/yql/minikql/computation/mkql_value_builder.h
+++ b/ydb/library/yql/minikql/computation/mkql_value_builder.h
@@ -57,9 +57,9 @@ public:
     bool GetSecureParam(NUdf::TStringRef key, NUdf::TStringRef &value) const final;
     const NUdf::TSourcePosition* CalleePosition() const final;
     NUdf::TUnboxedValue Run(const NUdf::TSourcePosition& callee, const NUdf::IBoxedValue& value, const NUdf::TUnboxedValuePod* args) const final;
-    NUdf::TFlatDataBlockPtr NewFlatDataBlock(ui32 initialSize, ui32 initialCapacity) const final;
-    NUdf::TFlatArrayBlockPtr NewFlatArrayBlock(ui32 count) const final;
-    NUdf::TSingleBlockPtr NewSingleBlock(const NUdf::TUnboxedValue& value) const final;
+    void Unused1() const final;
+    void Unused2() const final;
+    void Unused3() const final;
     bool MakeDate(ui32 year, ui32 month, ui32 day, ui16& value) const final;
     bool SplitDate(ui16 value, ui32& year, ui32& month, ui32& day) const final;
 
diff --git a/ydb/library/yql/public/udf/udf_value.h b/ydb/library/yql/public/udf/udf_value.h
index a8ae44ce94..c192c81dee 100644
--- a/ydb/library/yql/public/udf/udf_value.h
+++ b/ydb/library/yql/public/udf/udf_value.h
@@ -32,16 +32,6 @@ enum class EFetchStatus : ui32 {
     Yield
 };
 
-#if UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 19)
-enum class EBlockType : ui32 {
-    Flat,
-    Single
-};
-
-constexpr ui32 PreferredBlockRows = 65536;
-constexpr ui32 PreferredBlockBytes = 1000000;
-#endif
-
 ///////////////////////////////////////////////////////////////////////////////
 // IApplyContext
 ///////////////////////////////////////////////////////////////////////////////
@@ -52,15 +42,6 @@ public:
 
 UDF_ASSERT_TYPE_SIZE(IApplyContext, 8);
 
-#if UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 19)
-class TBlock;
-class TFlatDataBlock;
-class TFlatArrayBlock;
-class TSingleBlock;
-
-typedef bool(*TBlockCallback)(TBlock& block, void* context);
-#endif
-
 ///////////////////////////////////////////////////////////////////////////////
 // IBoxedValue
 ///////////////////////////////////////////////////////////////////////////////
@@ -70,7 +51,6 @@ using IBoxedValuePtr = TRefCountedPtr<IBoxedValue>;
 class IBoxedValue1
 {
 friend struct TBoxedValueAccessor;
-friend class TBlock;
 public:
     inline bool IsCompatibleTo(ui16 compatibilityVersion) const {
         return AbiCompatibility_ >= compatibilityVersion;
@@ -155,7 +135,6 @@ private:
 #if UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 3)
 class IBoxedValue2 : public IBoxedValue1 {
 friend struct TBoxedValueAccessor;
-friend class TBlock;
 private:
     // Save/Load state
     virtual ui32 GetTraverseCount() const = 0;
@@ -168,7 +147,6 @@ private:
 #if UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 11)
 class IBoxedValue3 : public IBoxedValue2 {
 friend struct TBoxedValueAccessor;
-friend class TBlock;
 private:
     virtual void Push(const TUnboxedValuePod& value) = 0;
 };
@@ -177,7 +155,6 @@ private:
 #if UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 12)
 class IBoxedValue4 : public IBoxedValue3 {
 friend struct TBoxedValueAccessor;
-friend class TBlock;
 private:
     virtual bool IsSortedDict() const = 0;
 };
@@ -186,14 +163,13 @@ private:
 #if UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 19)
 class IBoxedValue5 : public IBoxedValue4 {
 friend struct TBoxedValueAccessor;
-friend class TBlock;
 private:
-    virtual TBlock* AsBlock() = 0;
-    virtual TFlatArrayBlock* AsFlatArrayBlock() = 0;
-    virtual TFlatDataBlock* AsFlatDataBlock() = 0;
-    virtual TSingleBlock* AsSingleBlock() = 0;
-    virtual EFetchStatus FetchBlock(TUnboxedValue& result, ui32 rowsLimitHint) = 0;
-    virtual bool VisitBlocks(TBlockCallback callback, void* context) = 0;
+    virtual void Unused1() = 0;
+    virtual void Unused2() = 0;
+    virtual void Unused3() = 0;
+    virtual void Unused4() = 0;
+    virtual void Unused5() = 0;
+    virtual void Unused6() = 0;
 };
 #endif
 
@@ -213,183 +189,6 @@ UDF_ASSERT_TYPE_SIZE(IBoxedValue, 16);
 
 UDF_ASSERT_TYPE_SIZE(IBoxedValuePtr, 8);
 
-#if UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 19)
-///////////////////////////////////////////////////////////////////////////////
-// TBlock
-///////////////////////////////////////////////////////////////////////////////
-
-class TBlock : public IBoxedValue {
-public:
-    using IBoxedValue::AsFlatArrayBlock;
-    using IBoxedValue::AsFlatDataBlock;
-    using IBoxedValue::AsSingleBlock;
-
-    ui32 GetRows() const {
-        return Rows_;
-    }
-
-    void SetRows(ui32 rows) {
-        Rows_ = rows;
-    }
-
-    EBlockType GetType() {
-        return Type_;
-    }
-
-protected:
-    TBlock(EBlockType type, ui32 rows = 0)
-        : Type_(type)
-        , Rows_(rows)
-    {}
-
-private:
-    const EBlockType Type_;
-    ui32 Rows_;
-};
-
-UDF_ASSERT_TYPE_SIZE(TBlock, 24);
-
-using TBlockPtr = TRefCountedPtr<TBlock>;
-
-UDF_ASSERT_TYPE_SIZE(TBlockPtr, 8);
-
-///////////////////////////////////////////////////////////////////////////////
-// TFlatArrayBlock
-///////////////////////////////////////////////////////////////////////////////
-class TFlatArrayBlock : public TBlock {
-protected:
-    TFlatArrayBlock(ui32 count);
-    ~TFlatArrayBlock();
-
-public:
-    ui32 Count() const {
-        return Count_;
-    }
-
-    TBlockPtr* Items() const {
-        return Items_;
-    }
-
-    TBlockPtr GetItem(ui32 i) const {
-        Y_VERIFY_DEBUG(i < Count_);
-        return Items_[i];
-    }
-
-    void SetItem(ui32 i, TBlockPtr item) const {
-        Y_VERIFY_DEBUG(i < Count_);
-        Items_[i] = item;
-    }
-
-protected:
-    TBlockPtr* const Items_;
-    const ui32 Count_;
-    ui32 Reserved_ = 0;
-};
-
-UDF_ASSERT_TYPE_SIZE(TFlatArrayBlock, 40);
-
-using TFlatArrayBlockPtr = TRefCountedPtr<TFlatArrayBlock>;
-
-UDF_ASSERT_TYPE_SIZE(TFlatArrayBlockPtr, 8);
-
-///////////////////////////////////////////////////////////////////////////////
-// TFlatDataBlock
-///////////////////////////////////////////////////////////////////////////////
-class TFlatDataBlock : public TBlock {
-protected:
-    TFlatDataBlock()
-        : TBlock(EBlockType::Flat)
-        , Data_(nullptr)
-        , Capacity_(0)
-        , Size_(0)
-        , Iter_(0)
-        , Reserved_(0)
-    {
-        Y_UNUSED(Reserved_);
-    }
-
-public:
-    void* Data() const {
-        return Data_;
-    }
-
-    ui32 Capacity() const {
-        return Capacity_;
-    }
-
-    ui32 Size() const {
-        return Size_;
-    }
-
-    void Clear() {
-        Size_ = 0;
-        SetRows(0);
-    }
-
-    void AppendData(const void* data, ui32 len) {
-        if (Size_ + len > Capacity_) {
-            Grow(len);
-        }
-
-        if (len) {
-            memcpy(static_cast<char*>(Data_) + Size_, data, len);
-        }
-
-        Size_ += len;
-    }
-
-    template <typename T>
-    const T& GetPod(i32 index) {
-        static_assert(sizeof(T) <= 16);
-        i32 offset = index * sizeof(T);
-        Y_VERIFY_DEBUG(Size_ % sizeof(T) == 0 && index >= -1 && offset + sizeof(T) <= Size_);
-        return *reinterpret_cast<const T*>(static_cast<const char*>(Data_) + offset);
-    }
-
-    template <typename T>
-    void AppendPodData(T x) {
-        static_assert(sizeof(T) <= 16);
-        AppendData(&x, sizeof(T));
-    }
-
-    void AppendRow(const void* data, ui32 len) {
-        AppendData(data, len);
-        SetRows(GetRows() + 1);
-    }
-
-    template <typename T>
-    void AppendPodRow(T x) {
-        static_assert(sizeof(T) <= 16);
-        AppendRow(&x, sizeof(T));
-        SetRows(GetRows() + 1);
-    }
-
-    virtual void Grow(ui32 size) = 0;
-
-    ui32 GetIter() const {
-        return Iter_;
-    }
-
-    void SetIter(ui32 iter) {
-        Iter_ = iter;
-    }
-
-protected:
-    void* Data_;
-    ui32 Capacity_;
-    ui32 Size_;
-    ui32 Iter_;
-    ui32 Reserved_;
-};
-
-UDF_ASSERT_TYPE_SIZE(TFlatDataBlock, 48);
-
-using TFlatDataBlockPtr = TRefCountedPtr<TFlatDataBlock>;
-
-UDF_ASSERT_TYPE_SIZE(TFlatDataBlockPtr, 8);
-
-#endif
-
 ///////////////////////////////////////////////////////////////////////////////
 // TBoxedValueAccessor
 ///////////////////////////////////////////////////////////////////////////////
@@ -433,12 +232,12 @@ struct TBoxedValueAccessor
     xx(Load) \
     xx(Push) \
     xx(IsSortedDict) \
-    xx(AsBlock) \
-    xx(AsFlatArrayBlock) \
-    xx(AsFlatDataBlock) \
-    xx(AsSingleBlock) \
-    xx(FetchBlock) \
-    xx(VisitBlocks)
+    xx(Unused1) \
+    xx(Unused2) \
+    xx(Unused3) \
+    xx(Unused4) \
+    xx(Unused5) \
+    xx(Unused6)
 
 #elif UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 12)
 
@@ -678,15 +477,6 @@ struct TBoxedValueAccessor
 #if UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 12)
     static inline bool IsSortedDict(IBoxedValue& value);
 #endif
-
-#if UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 19)
-    static inline TBlock* AsBlock(IBoxedValue& value);
-    static inline TFlatArrayBlock* AsFlatArrayBlock(IBoxedValue& value);
-    static inline TFlatDataBlock* AsFlatDataBlock(IBoxedValue& value);
-    static inline TSingleBlock* AsSingleBlock(IBoxedValue& value);
-    static inline EFetchStatus FetchBlock(IBoxedValue& value, TUnboxedValue& result, ui32 rowsLimitHint);
-    static inline bool VisitBlocks(IBoxedValue& value, TBlockCallback callback, void* context);
-#endif
 };
 
 #define MAP_HANDLER(xx) template<> inline uintptr_t TBoxedValueAccessor::GetMethodPtr<TBoxedValueAccessor::EMethod::xx>() { return GetMethodPtr(&IBoxedValue::xx); }
@@ -764,12 +554,12 @@ private:
 #endif
 
 #if UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 19)
-    TBlock* AsBlock() override;
-    TFlatArrayBlock* AsFlatArrayBlock() override;
-    TFlatDataBlock* AsFlatDataBlock() override;
-    TSingleBlock* AsSingleBlock() override;
-    EFetchStatus FetchBlock(TUnboxedValue& result, ui32 rowsLimitHint) override;
-    bool VisitBlocks(TBlockCallback callback, void* context) override;
+    void Unused1() override;
+    void Unused2() override;
+    void Unused3() override;
+    void Unused4() override;
+    void Unused5() override;
+    void Unused6() override;
 #endif
 };
 
@@ -936,15 +726,6 @@ public:
     inline bool IsSortedDict() const;
 #endif
 
-#if UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 19)
-    inline TBlock* AsBlock();
-    inline TFlatArrayBlock* AsFlatArrayBlock();
-    inline TFlatDataBlock* AsFlatDataBlock();
-    inline TSingleBlock* AsSingleBlock();
-    inline EFetchStatus FetchBlock(TUnboxedValue& result, ui32 rowsLimitHint);
-    inline bool VisitBlocks(TBlockCallback callback, void* context);
-#endif
-
     inline bool TryMakeVariant(ui32 index);
 
     inline void SetTimezoneId(ui16 id);
@@ -1055,34 +836,6 @@ public:
 
 UDF_ASSERT_TYPE_SIZE(TUnboxedValue, 16);
 
-#if UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 19)
-///////////////////////////////////////////////////////////////////////////////
-// TSingleBlock
-///////////////////////////////////////////////////////////////////////////////
-class TSingleBlock: public TBlock {
-protected:
-    TSingleBlock(const TUnboxedValue& value)
-        : TBlock(EBlockType::Single)
-        , Value_(value)
-    {}
-
-public:
-    const TUnboxedValue& Value() const {
-        return Value_;
-    }
-
-private:
-    TUnboxedValue Value_;
-};
-
-UDF_ASSERT_TYPE_SIZE(TSingleBlock, 40);
-
-using TSingleBlockPtr = TRefCountedPtr<TSingleBlock>;
-
-UDF_ASSERT_TYPE_SIZE(TSingleBlockPtr, 8);
-
-#endif
-
 ///////////////////////////////////////////////////////////////////////////////
 // TBoxedResource
 ///////////////////////////////////////////////////////////////////////////////
@@ -1348,31 +1101,27 @@ inline bool TBoxedValueBase::IsSortedDict() const {
 #endif
 
 #if UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 19)
-inline TBlock* TBoxedValueBase::AsBlock() {
-    return nullptr;
+inline void TBoxedValueBase::Unused1() {
+    Y_FAIL("Not implemented");
 }
 
-inline TFlatArrayBlock* TBoxedValueBase::AsFlatArrayBlock() {
-    return nullptr;
+inline void TBoxedValueBase::Unused2() {
+    Y_FAIL("Not implemented");
 }
 
-inline TFlatDataBlock* TBoxedValueBase::AsFlatDataBlock() {
-    return nullptr;
+inline void TBoxedValueBase::Unused3() {
+    Y_FAIL("Not implemented");
 }
 
-inline TSingleBlock* TBoxedValueBase::AsSingleBlock() {
-    return nullptr;
+inline void TBoxedValueBase::Unused4() {
+    Y_FAIL("Not implemented");
 }
 
-inline EFetchStatus TBoxedValueBase::FetchBlock(TUnboxedValue& result, ui32 rowsLimitHint) {
-    Y_UNUSED(result);
-    Y_UNUSED(rowsLimitHint);
+inline void TBoxedValueBase::Unused5() {
     Y_FAIL("Not implemented");
 }
 
-inline bool TBoxedValueBase::VisitBlocks(TBlockCallback callback, void* context) {
-    Y_UNUSED(callback);
-    Y_UNUSED(context);
+inline void TBoxedValueBase::Unused6() {
     Y_FAIL("Not implemented");
 }
 #endif
diff --git a/ydb/library/yql/public/udf/udf_value_builder.h b/ydb/library/yql/public/udf/udf_value_builder.h
index c25876628f..9249377ee9 100644
--- a/ydb/library/yql/public/udf/udf_value_builder.h
+++ b/ydb/library/yql/public/udf/udf_value_builder.h
@@ -192,13 +192,9 @@ public:
 #if UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 19)
 class IValueBuilder5: public IValueBuilder4 {
 public:
-    virtual TFlatDataBlockPtr NewFlatDataBlock(ui32 initialSize, ui32 initialCapacity) const = 0;
-    virtual TFlatArrayBlockPtr NewFlatArrayBlock(ui32 count) const = 0;
-    TBlockPtr NewEmptyBlock() const {
-        return NewFlatArrayBlock(0).Get();
-    }
-
-    virtual TSingleBlockPtr NewSingleBlock(const TUnboxedValue& value) const = 0;
+    virtual void Unused1() const = 0;
+    virtual void Unused2() const = 0;
+    virtual void Unused3() const = 0;
 };
 #endif
 
diff --git a/ydb/library/yql/public/udf/udf_value_builder_ut.cpp b/ydb/library/yql/public/udf/udf_value_builder_ut.cpp
index 1b55e94822..afbf6c1e01 100644
--- a/ydb/library/yql/public/udf/udf_value_builder_ut.cpp
+++ b/ydb/library/yql/public/udf/udf_value_builder_ut.cpp
@@ -25,8 +25,9 @@ Y_UNIT_TEST_SUITE(TUdfValueBuilder) {
         UNIT_ASSERT_VALUES_EQUAL(17, GetMethodIndex(&IValueBuilder::GetSecureParam));
         UNIT_ASSERT_VALUES_EQUAL(18, GetMethodIndex(&IValueBuilder::CalleePosition));
         UNIT_ASSERT_VALUES_EQUAL(19, GetMethodIndex(&IValueBuilder::Run));
-        UNIT_ASSERT_VALUES_EQUAL(20, GetMethodIndex(&IValueBuilder::NewFlatDataBlock));
-        UNIT_ASSERT_VALUES_EQUAL(21, GetMethodIndex(&IValueBuilder::NewFlatArrayBlock));
-        UNIT_ASSERT_VALUES_EQUAL(22, GetMethodIndex(&IValueBuilder::NewSingleBlock));
+        UNIT_ASSERT_VALUES_EQUAL(20, GetMethodIndex(&IValueBuilder::Unused1));
+        UNIT_ASSERT_VALUES_EQUAL(21, GetMethodIndex(&IValueBuilder::Unused2));
+        UNIT_ASSERT_VALUES_EQUAL(22, GetMethodIndex(&IValueBuilder::Unused3));
+        UNIT_ASSERT_VALUES_EQUAL(23, GetMethodIndex(&IValueBuilder::GetPgBuilder));
     }
 }
diff --git a/ydb/library/yql/public/udf/udf_value_inl.h b/ydb/library/yql/public/udf/udf_value_inl.h
index eb2db28e18..bbe323cbd9 100644
--- a/ydb/library/yql/public/udf/udf_value_inl.h
+++ b/ydb/library/yql/public/udf/udf_value_inl.h
@@ -88,32 +88,6 @@ inline void IBoxedValue1::UnlockRef(i32 prev) noexcept {
    Refs_ = prev;
 }
 
-#if UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 19)
-//////////////////////////////////////////////////////////////////////////////
-// TFlatArrayBlock
-//////////////////////////////////////////////////////////////////////////////
-
-inline TFlatArrayBlock::TFlatArrayBlock(ui32 count)
-    : TBlock(EBlockType::Flat)
-    , Items_(count ? reinterpret_cast<TBlockPtr*>(UdfAllocateWithSize(count * sizeof(TBlockPtr))) : nullptr)
-    , Count_(count)
-{
-    Y_UNUSED(Reserved_);
-    for (ui32 i = 0; i < count; ++i) {
-        ::new(Items_ + i)TBlockPtr();
-    }
-}
-
-inline TFlatArrayBlock::~TFlatArrayBlock() {
-    for (ui32 i = 0; i < Count_; ++i) {
-        Items_[i] = nullptr;
-    }
-
-    UdfFreeWithSize(Items_, Count_ * sizeof(TBlockPtr));
-}
-
-#endif
-
 //////////////////////////////////////////////////////////////////////////////
 // TBoxedValueAccessor
 //////////////////////////////////////////////////////////////////////////////
@@ -302,39 +276,6 @@ inline bool TBoxedValueAccessor::IsSortedDict(IBoxedValue& value) {
 }
 #endif
 
-#if UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 19)
-inline TBlock* TBoxedValueAccessor::AsBlock(IBoxedValue& value) {
-    Y_VERIFY_DEBUG(value.IsCompatibleTo(MakeAbiCompatibilityVersion(2, 19)));
-    return value.AsBlock();
-}
-
-inline TFlatArrayBlock* TBoxedValueAccessor::AsFlatArrayBlock(IBoxedValue& value) {
-    Y_VERIFY_DEBUG(value.IsCompatibleTo(MakeAbiCompatibilityVersion(2, 19)));
-    return value.AsFlatArrayBlock();
-}
-
-inline TFlatDataBlock* TBoxedValueAccessor::AsFlatDataBlock(IBoxedValue& value) {
-    Y_VERIFY_DEBUG(value.IsCompatibleTo(MakeAbiCompatibilityVersion(2, 19)));
-    return value.AsFlatDataBlock();
-}
-
-inline TSingleBlock* TBoxedValueAccessor::AsSingleBlock(IBoxedValue& value) {
-    Y_VERIFY_DEBUG(value.IsCompatibleTo(MakeAbiCompatibilityVersion(2, 19)));
-    return value.AsSingleBlock();
-}
-
-inline EFetchStatus TBoxedValueAccessor::FetchBlock(IBoxedValue& value, TUnboxedValue& result, ui32 rowsLimitHint) {
-    Y_VERIFY_DEBUG(value.IsCompatibleTo(MakeAbiCompatibilityVersion(2, 19)));
-    return value.FetchBlock(result, rowsLimitHint);
-}
-
-inline bool TBoxedValueAccessor::VisitBlocks(IBoxedValue& value, TBlockCallback callback, void* context) {
-    Y_VERIFY_DEBUG(value.IsCompatibleTo(MakeAbiCompatibilityVersion(2, 19)));
-    return value.VisitBlocks(callback, context);
-}
-
-#endif
-
 //////////////////////////////////////////////////////////////////////////////
 // TUnboxedValue
 //////////////////////////////////////////////////////////////////////////////
@@ -653,38 +594,6 @@ inline bool TUnboxedValuePod::IsSortedDict() const {
 }
 #endif
 
-#if UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 19)
-inline TBlock* TUnboxedValuePod::AsBlock() {
-    UDF_VERIFY(IsBoxed(), "Value is not boxed");
-    return TBoxedValueAccessor::AsBlock(*Raw.Boxed.Value);
-}
-
-inline TFlatArrayBlock* TUnboxedValuePod::AsFlatArrayBlock() {
-    UDF_VERIFY(IsBoxed(), "Value is not boxed");
-    return TBoxedValueAccessor::AsFlatArrayBlock(*Raw.Boxed.Value);
-}
-
-inline TFlatDataBlock* TUnboxedValuePod::AsFlatDataBlock() {
-    UDF_VERIFY(IsBoxed(), "Value is not boxed");
-    return TBoxedValueAccessor::AsFlatDataBlock(*Raw.Boxed.Value);
-}
-
-inline TSingleBlock* TUnboxedValuePod::AsSingleBlock() {
-    UDF_VERIFY(IsBoxed(), "Value is not boxed");
-    return TBoxedValueAccessor::AsSingleBlock(*Raw.Boxed.Value);
-}
-
-inline EFetchStatus TUnboxedValuePod::FetchBlock(TUnboxedValue& result, ui32 rowsLimitHint) {
-    UDF_VERIFY(IsBoxed(), "Value is not boxed");
-    return TBoxedValueAccessor::FetchBlock(*Raw.Boxed.Value, result, rowsLimitHint);
-}
-
-inline bool TUnboxedValuePod::VisitBlocks(TBlockCallback callback, void* context) {
-    UDF_VERIFY(IsBoxed(), "Value is not boxed");
-    return TBoxedValueAccessor::VisitBlocks(*Raw.Boxed.Value, callback, context);
-}
-#endif
-
 Y_FORCE_INLINE void TUnboxedValuePod::Ref() const noexcept
 {
     switch (Raw.GetMarkers()) {
diff --git a/ydb/library/yql/public/udf/udf_value_ut.cpp b/ydb/library/yql/public/udf/udf_value_ut.cpp
index 8d9708c7b1..c83c124350 100644
--- a/ydb/library/yql/public/udf/udf_value_ut.cpp
+++ b/ydb/library/yql/public/udf/udf_value_ut.cpp
@@ -150,6 +150,21 @@ Y_UNIT_TEST_SUITE(TUdfValue) {
         UNIT_ASSERT_VALUES_EQUAL(33, METHOD_INDEX(Save));
         UNIT_ASSERT_VALUES_EQUAL(34, METHOD_INDEX(Load));
 #endif
+#if UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 11)
+        UNIT_ASSERT_VALUES_EQUAL(35, METHOD_INDEX(Push));
+#endif
+#if UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 12)
+        UNIT_ASSERT_VALUES_EQUAL(36, METHOD_INDEX(IsSortedDict));
+#endif
+#if UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 19)
+        UNIT_ASSERT_VALUES_EQUAL(37, METHOD_INDEX(Unused1));
+        UNIT_ASSERT_VALUES_EQUAL(38, METHOD_INDEX(Unused2));
+        UNIT_ASSERT_VALUES_EQUAL(39, METHOD_INDEX(Unused3));
+        UNIT_ASSERT_VALUES_EQUAL(40, METHOD_INDEX(Unused4));
+        UNIT_ASSERT_VALUES_EQUAL(41, METHOD_INDEX(Unused5));
+        UNIT_ASSERT_VALUES_EQUAL(42, METHOD_INDEX(Unused6));
+#endif
+
 #undef METHOD_INDEX
     }
 }