Initial support of PG types in arrow blocks (reader/builder)

36 files changed, 250 insertions, 84 deletions

diff --git a/ydb/library/yql/core/yql_opt_utils.cpp b/ydb/library/yql/core/yql_opt_utils.cpp
index 33ff385011e..d724c8e617f 100644
--- a/ydb/library/yql/core/yql_opt_utils.cpp
+++ b/ydb/library/yql/core/yql_opt_utils.cpp
@@ -1421,7 +1421,7 @@ ui64 GetTypeWeight(const TTypeAnnotationNode& type) {
             return 1 + GetTypeWeight(*type.Cast<TOptionalExprType>()->GetItemType());
         case ETypeAnnotationKind::Pg: {
             const auto& typeDesc = NPg::LookupType(type.Cast<TPgExprType>()->GetId());
-            if (typeDesc.TypeLen > 0 && typeDesc.PassByValue) {
+            if (typeDesc.PassByValue) {
                 return typeDesc.TypeLen;
             }
             return UnknownWeight;
diff --git a/ydb/library/yql/minikql/comp_nodes/mkql_block_agg.cpp b/ydb/library/yql/minikql/comp_nodes/mkql_block_agg.cpp
index 00edfc9ed65..53356d19f69 100644
--- a/ydb/library/yql/minikql/comp_nodes/mkql_block_agg.cpp
+++ b/ydb/library/yql/minikql/comp_nodes/mkql_block_agg.cpp
@@ -861,7 +861,7 @@ private:
             for (size_t i = 0; i < keys.size(); ++i) {
                 auto itemType = AS_TYPE(TBlockType, keys[i].Type)->GetItemType();
                 Readers_[i] = NYql::NUdf::MakeBlockReader(TTypeInfoHelper(), itemType);
-                Builders_[i] = NYql::NUdf::MakeArrayBuilder(TTypeInfoHelper(), itemType, ctx.ArrowMemoryPool, maxBlockLen);
+                Builders_[i] = NYql::NUdf::MakeArrayBuilder(TTypeInfoHelper(), itemType, ctx.ArrowMemoryPool, maxBlockLen, &ctx.Builder->GetPgBuilder());
             }
 
             if constexpr (Many) {
diff --git a/ydb/library/yql/minikql/comp_nodes/mkql_block_agg_minmax.cpp b/ydb/library/yql/minikql/comp_nodes/mkql_block_agg_minmax.cpp
index 00524d0b376..9f19ee56071 100644
--- a/ydb/library/yql/minikql/comp_nodes/mkql_block_agg_minmax.cpp
+++ b/ydb/library/yql/minikql/comp_nodes/mkql_block_agg_minmax.cpp
@@ -151,7 +151,7 @@ private:
 class TGenericColumnBuilder : public IAggColumnBuilder {
 public:
     TGenericColumnBuilder(ui64 size, TType* columnType, TComputationContext& ctx)
-        : Builder_(MakeArrayBuilder(TTypeInfoHelper(), columnType, ctx.ArrowMemoryPool, size))
+        : Builder_(MakeArrayBuilder(TTypeInfoHelper(), columnType, ctx.ArrowMemoryPool, size, &ctx.Builder->GetPgBuilder()))
         , Ctx_(ctx)
     {
     }
@@ -207,7 +207,7 @@ public:
         , ArgColumn_(argColumn)
         , ReaderOne_(MakeBlockReader(TTypeInfoHelper(), type))
         , ReaderTwo_(MakeBlockReader(TTypeInfoHelper(), type))
-        , Converter_(MakeBlockItemConverter(TTypeInfoHelper(), type))
+        , Converter_(MakeBlockItemConverter(TTypeInfoHelper(), type, ctx.Builder->GetPgBuilder()))
         , Compare_(NYql::NUdf::MakeBlockItemComparator(TTypeInfoHelper(), type))
     {
     }
@@ -293,7 +293,7 @@ public:
         , ArgColumn_(argColumn)
         , Type_(type)
         , Reader_(MakeBlockReader(TTypeInfoHelper(), type))
-        , Converter_(MakeBlockItemConverter(TTypeInfoHelper(), type))
+        , Converter_(MakeBlockItemConverter(TTypeInfoHelper(), type, ctx.Builder->GetPgBuilder()))
         , Compare_(NYql::NUdf::MakeBlockItemComparator(TTypeInfoHelper(), type))
     {
     }
@@ -337,7 +337,7 @@ public:
         , ArgColumn_(argColumn)
         , Type_(type)
         , Reader_(MakeBlockReader(TTypeInfoHelper(), type))
-        , Converter_(MakeBlockItemConverter(TTypeInfoHelper(), type))
+        , Converter_(MakeBlockItemConverter(TTypeInfoHelper(), type, ctx.Builder->GetPgBuilder()))
         , Compare_(NYql::NUdf::MakeBlockItemComparator(TTypeInfoHelper(), type))
 
     {
diff --git a/ydb/library/yql/minikql/comp_nodes/mkql_block_agg_some.cpp b/ydb/library/yql/minikql/comp_nodes/mkql_block_agg_some.cpp
index 8f9aec1f78e..a4e205cb26e 100644
--- a/ydb/library/yql/minikql/comp_nodes/mkql_block_agg_some.cpp
+++ b/ydb/library/yql/minikql/comp_nodes/mkql_block_agg_some.cpp
@@ -33,7 +33,7 @@ void PushValueToState(TGenericState* typedState, const arrow::Datum& datum, ui64
 class TGenericColumnBuilder : public IAggColumnBuilder {
 public:
     TGenericColumnBuilder(ui64 size, TType* columnType, TComputationContext& ctx)
-        : Builder_(MakeArrayBuilder(TTypeInfoHelper(), columnType, ctx.ArrowMemoryPool, size))
+        : Builder_(MakeArrayBuilder(TTypeInfoHelper(), columnType, ctx.ArrowMemoryPool, size, &ctx.Builder->GetPgBuilder()))
         , Ctx_(ctx)
     {
     }
@@ -63,7 +63,7 @@ public:
         : TBase(sizeof(TGenericState), filterColumn, ctx)
         , ArgColumn_(argColumn)
         , Reader_(MakeBlockReader(TTypeInfoHelper(), type))
-        , Converter_(MakeBlockItemConverter(TTypeInfoHelper(), type))
+        , Converter_(MakeBlockItemConverter(TTypeInfoHelper(), type, ctx.Builder->GetPgBuilder()))
     {
     }
 
@@ -134,7 +134,7 @@ public:
         , ArgColumn_(argColumn)
         , Type_(type)
         , Reader_(MakeBlockReader(TTypeInfoHelper(), type))
-        , Converter_(MakeBlockItemConverter(TTypeInfoHelper(), type))
+        , Converter_(MakeBlockItemConverter(TTypeInfoHelper(), type, ctx.Builder->GetPgBuilder()))
     {
     }
 
@@ -180,7 +180,7 @@ public:
         , ArgColumn_(argColumn)
         , Type_(type)
         , Reader_(MakeBlockReader(TTypeInfoHelper(), type))
-        , Converter_(MakeBlockItemConverter(TTypeInfoHelper(), type))
+        , Converter_(MakeBlockItemConverter(TTypeInfoHelper(), type, ctx.Builder->GetPgBuilder()))
     {
     }
 
diff --git a/ydb/library/yql/minikql/comp_nodes/mkql_block_agg_sum.cpp b/ydb/library/yql/minikql/comp_nodes/mkql_block_agg_sum.cpp
index d5eb55672bd..5131f5cf0ff 100644
--- a/ydb/library/yql/minikql/comp_nodes/mkql_block_agg_sum.cpp
+++ b/ydb/library/yql/minikql/comp_nodes/mkql_block_agg_sum.cpp
@@ -71,7 +71,7 @@ class TAvgStateColumnBuilder : public IAggColumnBuilder {
 public:
     TAvgStateColumnBuilder(ui64 size, TType* outputType, TComputationContext& ctx)
         : Ctx_(ctx)
-        , Builder_(MakeArrayBuilder(TTypeInfoHelper(), outputType, ctx.ArrowMemoryPool, size))
+        , Builder_(MakeArrayBuilder(TTypeInfoHelper(), outputType, ctx.ArrowMemoryPool, size, &ctx.Builder->GetPgBuilder()))
 {
     }
 
diff --git a/ydb/library/yql/minikql/comp_nodes/mkql_block_compress.cpp b/ydb/library/yql/minikql/comp_nodes/mkql_block_compress.cpp
index bd83ebe6f98..f0c5108e416 100644
--- a/ydb/library/yql/minikql/comp_nodes/mkql_block_compress.cpp
+++ b/ydb/library/yql/minikql/comp_nodes/mkql_block_compress.cpp
@@ -263,7 +263,7 @@ private:
         bool HaveBlocks_ = false;
 
         TState(TMemoryUsageInfo* memInfo, ui32 width, ui32 bitmapIndex, NUdf::TUnboxedValue*const* output,
-            const TVector<TBlockType*>& types, arrow::MemoryPool& pool)
+            const TVector<TBlockType*>& types, arrow::MemoryPool& pool, const NUdf::IPgBuilder& pgBuilder)
             : TComputationValue(memInfo)
             , ValuePointers_(width)
             , InputValues_(width)
@@ -289,7 +289,7 @@ private:
             for (ui32 i = 0, outIndex = 0; i < width; ++i) {
                 if (i != bitmapIndex) {
                     if (types[i]->GetShape() != TBlockType::EShape::Scalar && output[outIndex] != nullptr) {
-                        Builders_[i] = MakeArrayBuilder(TTypeInfoHelper(), types[i]->GetItemType(), pool, maxBlockLen);
+                        Builders_[i] = MakeArrayBuilder(TTypeInfoHelper(), types[i]->GetItemType(), pool, maxBlockLen, &pgBuilder);
                     }
                     outIndex++;
                 }
@@ -304,7 +304,7 @@ private:
 
     TState& GetState(NUdf::TUnboxedValue& state, TComputationContext& ctx, NUdf::TUnboxedValue*const* output) const {
         if (!state.HasValue()) {
-            state = ctx.HolderFactory.Create<TState>(Width_, BitmapIndex_, output, Types_, ctx.ArrowMemoryPool);
+            state = ctx.HolderFactory.Create<TState>(Width_, BitmapIndex_, output, Types_, ctx.ArrowMemoryPool, ctx.Builder->GetPgBuilder());
         }
         return *static_cast<TState*>(state.AsBoxed().Get());
     }
diff --git a/ydb/library/yql/minikql/comp_nodes/mkql_block_if.cpp b/ydb/library/yql/minikql/comp_nodes/mkql_block_if.cpp
index 10c3e41d8a3..37c4f88c61b 100644
--- a/ydb/library/yql/minikql/comp_nodes/mkql_block_if.cpp
+++ b/ydb/library/yql/minikql/comp_nodes/mkql_block_if.cpp
@@ -105,7 +105,7 @@ public:
         const std::shared_ptr<arrow::ArrayData>& pred = predDatum.array();
 
         const size_t len = pred->length;
-        auto builder = MakeArrayBuilder(TTypeInfoHelper(), Type, *ctx->memory_pool(), len);
+        auto builder = MakeArrayBuilder(TTypeInfoHelper(), Type, *ctx->memory_pool(), len, nullptr);
         const ui8* predValues = pred->GetValues<uint8_t>(1);
         for (size_t i = 0; i < len; ++i) {
             if constexpr (!ThenIsScalar) {
diff --git a/ydb/library/yql/minikql/comp_nodes/mkql_block_impl.cpp b/ydb/library/yql/minikql/comp_nodes/mkql_block_impl.cpp
index 6610a0de3a5..7bca187600f 100644
--- a/ydb/library/yql/minikql/comp_nodes/mkql_block_impl.cpp
+++ b/ydb/library/yql/minikql/comp_nodes/mkql_block_impl.cpp
@@ -28,7 +28,7 @@ std::vector<arrow::ValueDescr> ToValueDescr(const TVector<TType*>& types) {
 arrow::Datum MakeArrayFromScalar(const arrow::Scalar& scalar, size_t len, TType* type, arrow::MemoryPool& pool) {
     MKQL_ENSURE(len > 0, "Invalid block size");
     auto reader = MakeBlockReader(TTypeInfoHelper(), type);
-    auto builder = MakeArrayBuilder(TTypeInfoHelper(), type, pool, len);
+    auto builder = MakeArrayBuilder(TTypeInfoHelper(), type, pool, len, nullptr);
 
     auto scalarItem = reader->GetScalarItem(scalar);
     for (size_t i = 0; i < len; ++i) {
diff --git a/ydb/library/yql/minikql/comp_nodes/mkql_block_reader.cpp b/ydb/library/yql/minikql/comp_nodes/mkql_block_reader.cpp
index fb6c555b324..581bc112eb5 100644
--- a/ydb/library/yql/minikql/comp_nodes/mkql_block_reader.cpp
+++ b/ydb/library/yql/minikql/comp_nodes/mkql_block_reader.cpp
@@ -39,9 +39,16 @@ public:
     }
 };
 
-template<typename TStringType, bool Nullable>
+template<typename TStringType, bool Nullable, NUdf::EPgStringType PgString>
 class TStringBlockItemConverter : public IBlockItemConverter {
 public:
+    void SetPgBuilder(const NUdf::IPgBuilder* pgBuilder, i32 typeLen, ui32 pgTypeId) {
+        Y_ENSURE(PgString != NUdf::EPgStringType::None);
+        PgBuilder = pgBuilder;
+        TypeLen = typeLen;
+        PgTypeId = pgTypeId;
+    }
+
     NUdf::TUnboxedValuePod MakeValue(TBlockItem item, const THolderFactory& holderFactory) const final {
         Y_UNUSED(holderFactory);
         if constexpr (Nullable) {
@@ -50,7 +57,11 @@ public:
             }
         }
 
-        return MakeString(item.AsStringRef());
+        if constexpr (PgString != NUdf::EPgStringType::None) {
+             return PgBuilder->NewString(TypeLen, PgTypeId, item.AsStringRef()).Release();
+        } else {
+            return MakeString(item.AsStringRef());
+        }
     }
 
     TBlockItem MakeItem(NUdf::TUnboxedValuePod value) const final {
@@ -60,8 +71,19 @@ public:
             }
         }
 
-        return TBlockItem(value.AsStringRef());
+        if constexpr (PgString == NUdf::EPgStringType::CString) {
+            return TBlockItem(PgBuilder->AsCStringBuffer(value));
+        } else if constexpr (PgString == NUdf::EPgStringType::Text) {
+            return TBlockItem(PgBuilder->AsTextBuffer(value));
+        } else {
+            return TBlockItem(value.AsStringRef());
+        }
     }
+
+private:
+    const NUdf::IPgBuilder* PgBuilder = nullptr;
+    i32 TypeLen = 0;
+    ui32 PgTypeId = 0;
 };
 
 template <bool Nullable>
@@ -152,15 +174,15 @@ struct TConverterTraits {
     using TTuple = TTupleBlockItemConverter<Nullable>;
     template <typename T, bool Nullable>
     using TFixedSize = TFixedSizeBlockItemConverter<T, Nullable>;
-    template <typename TStringType, bool Nullable>
-    using TStrings = TStringBlockItemConverter<TStringType, Nullable>;
+    template <typename TStringType, bool Nullable, NUdf::EPgStringType PgString>
+    using TStrings = TStringBlockItemConverter<TStringType, Nullable, PgString>;
     using TExtOptional = TExternalOptionalBlockItemConverter;
 };
 
 } // namespace
 
-std::unique_ptr<IBlockItemConverter> MakeBlockItemConverter(const NYql::NUdf::ITypeInfoHelper& typeInfoHelper, const NYql::NUdf::TType* type) {
-    return NYql::NUdf::MakeBlockReaderImpl<TConverterTraits>(typeInfoHelper, type);
+std::unique_ptr<IBlockItemConverter> MakeBlockItemConverter(const NYql::NUdf::ITypeInfoHelper& typeInfoHelper, const NYql::NUdf::TType* type, const NUdf::IPgBuilder& pgBuilder) {
+    return NYql::NUdf::MakeBlockReaderImpl<TConverterTraits>(typeInfoHelper, type, &pgBuilder);
 }
 
 } // namespace NMiniKQL
diff --git a/ydb/library/yql/minikql/comp_nodes/mkql_block_reader.h b/ydb/library/yql/minikql/comp_nodes/mkql_block_reader.h
index c8f934717e6..6ca39f76c2e 100644
--- a/ydb/library/yql/minikql/comp_nodes/mkql_block_reader.h
+++ b/ydb/library/yql/minikql/comp_nodes/mkql_block_reader.h
@@ -27,6 +27,7 @@ using NYql::NUdf::MakeBlockReader;
 using NYql::NUdf::TBlockItemSerializeProps;
 using NYql::NUdf::UpdateBlockItemSerializeProps;
 
-std::unique_ptr<IBlockItemConverter> MakeBlockItemConverter(const NYql::NUdf::ITypeInfoHelper& typeInfoHelper, const NYql::NUdf::TType* type);
+std::unique_ptr<IBlockItemConverter> MakeBlockItemConverter(const NYql::NUdf::ITypeInfoHelper& typeInfoHelper, const NYql::NUdf::TType* type,
+    const NYql::NUdf::IPgBuilder& pgBuilder);
 
 }
diff --git a/ydb/library/yql/minikql/comp_nodes/mkql_block_top.cpp b/ydb/library/yql/minikql/comp_nodes/mkql_block_top.cpp
index 9b53c713ef3..f51fd0e7890 100644
--- a/ydb/library/yql/minikql/comp_nodes/mkql_block_top.cpp
+++ b/ydb/library/yql/minikql/comp_nodes/mkql_block_top.cpp
@@ -258,7 +258,7 @@ private:
                     continue;
                 }
 
-                Builders_[i] = MakeArrayBuilder(TTypeInfoHelper(), columns[i]->GetItemType(), ctx.ArrowMemoryPool, BuilderMaxLength_);
+                Builders_[i] = MakeArrayBuilder(TTypeInfoHelper(), columns[i]->GetItemType(), ctx.ArrowMemoryPool, BuilderMaxLength_, &ctx.Builder->GetPgBuilder());
             }
         }
 
diff --git a/ydb/library/yql/minikql/comp_nodes/mkql_blocks.cpp b/ydb/library/yql/minikql/comp_nodes/mkql_blocks.cpp
index 2074fab98c1..f82e2d1747b 100644
--- a/ydb/library/yql/minikql/comp_nodes/mkql_blocks.cpp
+++ b/ydb/library/yql/minikql/comp_nodes/mkql_blocks.cpp
@@ -30,7 +30,7 @@ public:
 
     NUdf::TUnboxedValuePod DoCalculate(TComputationContext& ctx) const {
         const auto maxLen = CalcBlockLen(CalcMaxBlockItemSize(ItemType_));
-        auto builder = MakeArrayBuilder(TTypeInfoHelper(), ItemType_, ctx.ArrowMemoryPool, maxLen);
+        auto builder = MakeArrayBuilder(TTypeInfoHelper(), ItemType_, ctx.ArrowMemoryPool, maxLen, &ctx.Builder->GetPgBuilder());
 
         for (size_t i = 0; i < builder->MaxLength(); ++i) {
             auto result = Flow_->GetValue(ctx);
@@ -132,7 +132,7 @@ private:
 
             for (size_t i = 0; i < types.size(); ++i) {
                 ValuePointers_[i] = &Values_[i];
-                Builders_.push_back(MakeArrayBuilder(TTypeInfoHelper(), types[i], ctx.ArrowMemoryPool, MaxLength_));
+                Builders_.push_back(MakeArrayBuilder(TTypeInfoHelper(), types[i], ctx.ArrowMemoryPool, MaxLength_, &ctx.Builder->GetPgBuilder()));
             }
         }
     };
@@ -190,10 +190,10 @@ private:
     struct TState : public TComputationValue<TState> {
         using TComputationValue::TComputationValue;
 
-        TState(TMemoryUsageInfo* memInfo, TType* itemType)
+        TState(TMemoryUsageInfo* memInfo, TType* itemType, const NUdf::IPgBuilder& pgBuilder)
             : TComputationValue(memInfo)
             , Reader_(MakeBlockReader(TTypeInfoHelper(), itemType))
-            , Converter_(MakeBlockItemConverter(TTypeInfoHelper(), itemType))
+            , Converter_(MakeBlockItemConverter(TTypeInfoHelper(), itemType, pgBuilder))
         {
         }
 
@@ -239,7 +239,7 @@ private:
     TState& GetState(TComputationContext& ctx) const {
         auto& result = ctx.MutableValues[StateIndex_];
         if (!result.HasValue()) {
-            result = ctx.HolderFactory.Create<TState>(ItemType_);
+            result = ctx.HolderFactory.Create<TState>(ItemType_, ctx.Builder->GetPgBuilder());
         }
         return *static_cast<TState*>(result.AsBoxed().Get());
     }
@@ -307,7 +307,7 @@ private:
         size_t Count_ = 0;
         size_t Index_ = 0;
 
-        TState(TMemoryUsageInfo* memInfo, const TVector<TType*>& types)
+        TState(TMemoryUsageInfo* memInfo, const TVector<TType*>& types, const NUdf::IPgBuilder& pgBuilder)
             : TComputationValue(memInfo)
             , Values_(types.size() + 1)
             , ValuePointers_(types.size() + 1)
@@ -318,7 +318,7 @@ private:
 
             for (size_t i = 0; i < types.size(); ++i) {
                 Readers_.push_back(MakeBlockReader(TTypeInfoHelper(), types[i]));
-                Converters_.push_back(MakeBlockItemConverter(TTypeInfoHelper(), types[i]));
+                Converters_.push_back(MakeBlockItemConverter(TTypeInfoHelper(), types[i], pgBuilder));
             }
         }
     };
@@ -330,7 +330,7 @@ private:
 
     TState& GetState(NUdf::TUnboxedValue& state, TComputationContext& ctx) const {
         if (!state.HasValue()) {
-            state = ctx.HolderFactory.Create<TState>(Types_);
+            state = ctx.HolderFactory.Create<TState>(Types_, ctx.Builder->GetPgBuilder());
         }
         return *static_cast<TState*>(state.AsBoxed().Get());
     }
diff --git a/ydb/library/yql/minikql/mkql_type_builder.cpp b/ydb/library/yql/minikql/mkql_type_builder.cpp
index 3593af50337..cf028560347 100644
--- a/ydb/library/yql/minikql/mkql_type_builder.cpp
+++ b/ydb/library/yql/minikql/mkql_type_builder.cpp
@@ -1488,7 +1488,7 @@ bool ConvertArrowType(NUdf::EDataSlot slot, std::shared_ptr<arrow::DataType>& ty
 bool ConvertArrowType(TType* itemType, std::shared_ptr<arrow::DataType>& type) {
     bool isOptional;
     auto unpacked = UnpackOptional(itemType, isOptional);
-    if (unpacked->IsOptional()) {
+    if (unpacked->IsOptional() || isOptional && unpacked->IsPg()) {
         // at least 2 levels of optionals
         ui32 nestLevel = 0;
         auto currentType = itemType;
@@ -1533,6 +1533,18 @@ bool ConvertArrowType(TType* itemType, std::shared_ptr<arrow::DataType>& type) {
         return true;
     }
 
+    if (unpacked->IsPg()) {
+        auto pgType = AS_TYPE(TPgType, unpacked);
+        const auto& desc = NYql::NPg::LookupType(pgType->GetTypeId());
+        if (desc.PassByValue) {
+            type = arrow::uint64();
+        } else {
+            type = arrow::binary();
+        }
+
+        return true;
+    }
+
     if (!unpacked->IsData()) {
         return false;
     }
@@ -2334,6 +2346,16 @@ size_t CalcMaxBlockItemSize(const TType* type) {
         return result;
     }
 
+    if (type->IsPg()) {
+        auto pgType = AS_TYPE(TPgType, type);
+        const auto& desc = NYql::NPg::LookupType(pgType->GetTypeId());
+        if (desc.PassByValue) {
+            return 8;
+        } else {
+            return sizeof(arrow::BinaryType::offset_type);
+        }
+    }
+
     if (type->IsData()) {
         auto slot = *AS_TYPE(TDataType, type)->GetDataSlot();
         switch (slot) {
diff --git a/ydb/library/yql/parser/pg_catalog/catalog.cpp b/ydb/library/yql/parser/pg_catalog/catalog.cpp
index efdc6156819..4ffe25c4c51 100644
--- a/ydb/library/yql/parser/pg_catalog/catalog.cpp
+++ b/ydb/library/yql/parser/pg_catalog/catalog.cpp
@@ -430,6 +430,7 @@ public:
 
     void OnFinish() override {
         Y_ENSURE(!LastType.Name.empty());
+        Y_ENSURE(LastType.TypeLen != 0);
         if (LastType.TypeLen < 0 || LastType.TypeLen > 8) {
             Y_ENSURE(!LastType.PassByValue);
         }
diff --git a/ydb/library/yql/parser/pg_wrapper/arrow.h b/ydb/library/yql/parser/pg_wrapper/arrow.h
index 5346a7aa63c..77aa4dc70aa 100644
--- a/ydb/library/yql/parser/pg_wrapper/arrow.h
+++ b/ydb/library/yql/parser/pg_wrapper/arrow.h
@@ -184,7 +184,7 @@ void GenericExecImpl2(bool hasScalars, bool hasNulls, arrow::compute::KernelCont
                 GenericExecImpl<TFunc, IsStrict, IsFixedResult, true, true, TArgsPolicy>(batch, length, state, builder, fcinfo);
                 *res = builder.Build(true);
             } else {
-                NUdf::TStringArrayBuilder<arrow::BinaryType, true> builder(NKikimr::NMiniKQL::TTypeInfoHelper(), arrow::uint64(), *ctx->memory_pool(), length);
+                NUdf::TStringArrayBuilder<arrow::BinaryType, true, NUdf::EPgStringType::None> builder(NKikimr::NMiniKQL::TTypeInfoHelper(), arrow::uint64(), *ctx->memory_pool(), length);
                 GenericExecImpl<TFunc, IsStrict, IsFixedResult, true, true, TArgsPolicy>(batch, length, state, builder, fcinfo);
                 *res = builder.Build(true);
             }
@@ -194,7 +194,7 @@ void GenericExecImpl2(bool hasScalars, bool hasNulls, arrow::compute::KernelCont
                 GenericExecImpl<TFunc, IsStrict, IsFixedResult, true, false, TArgsPolicy>(batch, length, state, builder, fcinfo);
                 *res = builder.Build(true);
             } else {
-                NUdf::TStringArrayBuilder<arrow::BinaryType, true> builder(NKikimr::NMiniKQL::TTypeInfoHelper(), arrow::uint64(), *ctx->memory_pool(), length);
+                NUdf::TStringArrayBuilder<arrow::BinaryType, true, NUdf::EPgStringType::None> builder(NKikimr::NMiniKQL::TTypeInfoHelper(), arrow::uint64(), *ctx->memory_pool(), length);
                 GenericExecImpl<TFunc, IsStrict, IsFixedResult, true, false, TArgsPolicy>(batch, length, state, builder, fcinfo);
                 *res = builder.Build(true);
             }
diff --git a/ydb/library/yql/parser/pg_wrapper/comp_factory.cpp b/ydb/library/yql/parser/pg_wrapper/comp_factory.cpp
index a6775025147..606e149a8b7 100644
--- a/ydb/library/yql/parser/pg_wrapper/comp_factory.cpp
+++ b/ydb/library/yql/parser/pg_wrapper/comp_factory.cpp
@@ -2889,6 +2889,16 @@ public:
     NUdf::TUnboxedValue NewString(i32 typeLen, ui32 targetTypeId, NUdf::TStringRef data) const override {
         return CreatePgString(typeLen, targetTypeId, data);
     }
+
+    NUdf::TStringRef AsCStringBuffer(const NUdf::TUnboxedValue& value) const override {
+        auto x = (const char*)value.AsBoxed().Get() + PallocHdrSize;
+        return { x, strlen(x) };
+    }
+
+    NUdf::TStringRef AsTextBuffer(const NUdf::TUnboxedValue& value) const override {
+        auto x = (const text*)((const char*)value.AsBoxed().Get() + PallocHdrSize);
+        return GetVarBuf(x);
+    }
 };
 
 std::unique_ptr<NUdf::IPgBuilder> CreatePgBuilder() {
diff --git a/ydb/library/yql/public/udf/arrow/block_builder.h b/ydb/library/yql/public/udf/arrow/block_builder.h
index b4c71f235e3..ca1be1df58c 100644
--- a/ydb/library/yql/public/udf/arrow/block_builder.h
+++ b/ydb/library/yql/public/udf/arrow/block_builder.h
@@ -6,6 +6,7 @@
 #include "block_item.h"
 
 #include <ydb/library/yql/public/udf/udf_value.h>
+#include <ydb/library/yql/public/udf/udf_value_builder.h>
 #include <ydb/library/yql/public/udf/udf_type_inspection.h>
 
 #include <arrow/datum.h>
@@ -431,7 +432,7 @@ private:
     std::unique_ptr<TTypedBufferBuilder<T>> DataBuilder;
 };
 
-template<typename TStringType, bool Nullable>
+template<typename TStringType, bool Nullable, EPgStringType PgString = EPgStringType::None>
 class TStringArrayBuilder final : public TArrayBuilderBase {
 public:
     using TOffset = typename TStringType::offset_type;
@@ -447,6 +448,11 @@ public:
         Reserve();
     }
 
+    void SetPgBuilder(const NUdf::IPgBuilder* pgBuilder) {
+        Y_ENSURE(PgString != EPgStringType::None);
+        PgBuilder = pgBuilder;
+    }
+
     void DoAdd(NUdf::TUnboxedValuePod value) final {
         if constexpr (Nullable) {
             if (!value) {
@@ -454,7 +460,15 @@ public:
             }
         }
 
-        DoAdd(TBlockItem(value.AsStringRef()));
+        if constexpr (PgString == EPgStringType::CString) {
+            static_assert(Nullable);
+            DoAdd(TBlockItem(PgBuilder->AsCStringBuffer(value)));
+        } else if constexpr (PgString == EPgStringType::Text) {
+            static_assert(Nullable);
+            DoAdd(TBlockItem(PgBuilder->AsTextBuffer(value)));
+        } else {
+            DoAdd(TBlockItem(value.AsStringRef()));
+        }
     }
 
     void DoAdd(TBlockItem value) final {
@@ -719,6 +733,8 @@ private:
     std::unique_ptr<TTypedBufferBuilder<ui8>> DataBuilder;
 
     std::deque<std::shared_ptr<arrow::ArrayData>> Chunks;
+
+    const IPgBuilder* PgBuilder = nullptr;
 };
 
 template<bool Nullable>
@@ -997,10 +1013,14 @@ private:
     std::unique_ptr<TTypedBufferBuilder<ui8>> NullBuilder;
 };
 
-std::unique_ptr<TArrayBuilderBase> MakeArrayBuilderBase(const ITypeInfoHelper& typeInfoHelper, const TType* type, arrow::MemoryPool& pool, size_t maxBlockLength);
+std::unique_ptr<TArrayBuilderBase> MakeArrayBuilderBase(
+    const ITypeInfoHelper& typeInfoHelper, const TType* type, arrow::MemoryPool& pool, 
+    size_t maxBlockLength, const IPgBuilder* pgBuilder);
 
 template<bool Nullable>
-inline std::unique_ptr<TArrayBuilderBase> MakeArrayBuilderImpl(const ITypeInfoHelper& typeInfoHelper, const TType* type, arrow::MemoryPool& pool, size_t maxLen) {
+inline std::unique_ptr<TArrayBuilderBase> MakeArrayBuilderImpl(
+    const ITypeInfoHelper& typeInfoHelper, const TType* type, arrow::MemoryPool& pool, 
+    size_t maxLen, const IPgBuilder* pgBuilder) {
     if constexpr (Nullable) {
         TOptionalTypeInspector typeOpt(typeInfoHelper, type);
         type = typeOpt.GetItemType();
@@ -1011,7 +1031,7 @@ inline std::unique_ptr<TArrayBuilderBase> MakeArrayBuilderImpl(const ITypeInfoHe
         TVector<std::unique_ptr<TArrayBuilderBase>> children;
         for (ui32 i = 0; i < typeTuple.GetElementsCount(); ++i) {
             const TType* childType = typeTuple.GetElementType(i);
-            auto childBuilder = MakeArrayBuilderBase(typeInfoHelper, childType, pool, maxLen);
+            auto childBuilder = MakeArrayBuilderBase(typeInfoHelper, childType, pool, maxLen, pgBuilder);
             children.push_back(std::move(childBuilder));
         }
 
@@ -1056,10 +1076,30 @@ inline std::unique_ptr<TArrayBuilderBase> MakeArrayBuilderImpl(const ITypeInfoHe
         }
     }
 
+    TPgTypeInspector typePg(typeInfoHelper, type);
+    if (typePg) {
+        auto desc = typeInfoHelper.FindPgTypeDescription(typePg.GetTypeId());
+        if (desc->PassByValue) {
+            return std::make_unique<TFixedSizeArrayBuilder<ui64, true>>(typeInfoHelper, type, pool, maxLen);
+        } else {
+            if (desc->Typelen == -1) {
+                auto ret = std::make_unique<TStringArrayBuilder<arrow::BinaryType, true, EPgStringType::Text>>(typeInfoHelper, type, pool, maxLen);
+                ret->SetPgBuilder(pgBuilder);
+                return ret;
+            } else {
+                auto ret = std::make_unique<TStringArrayBuilder<arrow::BinaryType, true, EPgStringType::CString>>(typeInfoHelper, type, pool, maxLen);
+                ret->SetPgBuilder(pgBuilder);
+                return ret;
+            }
+        }
+    }
+
     Y_ENSURE(false, "Unsupported type");
 }
 
-inline std::unique_ptr<TArrayBuilderBase> MakeArrayBuilderBase(const ITypeInfoHelper& typeInfoHelper, const TType* type, arrow::MemoryPool& pool, size_t maxBlockLength) {
+inline std::unique_ptr<TArrayBuilderBase> MakeArrayBuilderBase(
+    const ITypeInfoHelper& typeInfoHelper, const TType* type, arrow::MemoryPool& pool, 
+    size_t maxBlockLength, const IPgBuilder* pgBuilder) {
     const TType* unpacked = type;
     TOptionalTypeInspector typeOpt(typeInfoHelper, type);
     if (typeOpt) {
@@ -1067,7 +1107,8 @@ inline std::unique_ptr<TArrayBuilderBase> MakeArrayBuilderBase(const ITypeInfoHe
     }
 
     TOptionalTypeInspector unpackedOpt(typeInfoHelper, unpacked);
-    if (unpackedOpt) {
+    TPgTypeInspector unpackedPg(typeInfoHelper, unpacked);
+    if (unpackedOpt || typeOpt && unpackedPg) {
         // at least 2 levels of optionals
         ui32 nestLevel = 0;
         auto currentType = type;
@@ -1085,7 +1126,7 @@ inline std::unique_ptr<TArrayBuilderBase> MakeArrayBuilderBase(const ITypeInfoHe
             }
         }
 
-        auto builder = MakeArrayBuilderBase(typeInfoHelper, previousType, pool, maxBlockLength);
+        auto builder = MakeArrayBuilderBase(typeInfoHelper, previousType, pool, maxBlockLength, pgBuilder);
         for (ui32 i = 1; i < nestLevel; ++i) {
             builder = std::make_unique<TExternalOptionalArrayBuilder>(typeInfoHelper, types[nestLevel - 1 - i], pool, maxBlockLength, std::move(builder));
         }
@@ -1093,15 +1134,17 @@ inline std::unique_ptr<TArrayBuilderBase> MakeArrayBuilderBase(const ITypeInfoHe
         return builder;
     } else {
         if (typeOpt) {
-            return MakeArrayBuilderImpl<true>(typeInfoHelper, type, pool, maxBlockLength);
+            return MakeArrayBuilderImpl<true>(typeInfoHelper, type, pool, maxBlockLength, pgBuilder);
         } else {
-            return MakeArrayBuilderImpl<false>(typeInfoHelper, type, pool, maxBlockLength);
+            return MakeArrayBuilderImpl<false>(typeInfoHelper, type, pool, maxBlockLength, pgBuilder);
         }
     }
 }
 
-inline std::unique_ptr<IArrayBuilder> MakeArrayBuilder(const ITypeInfoHelper& typeInfoHelper, const TType* type, arrow::MemoryPool& pool, size_t maxBlockLength) {
-    return MakeArrayBuilderBase(typeInfoHelper, type, pool, maxBlockLength);
+inline std::unique_ptr<IArrayBuilder> MakeArrayBuilder(
+    const ITypeInfoHelper& typeInfoHelper, const TType* type, arrow::MemoryPool& pool, 
+    size_t maxBlockLength, const IPgBuilder* pgBuilder) {
+    return MakeArrayBuilderBase(typeInfoHelper, type, pool, maxBlockLength, pgBuilder);
 }
 
 inline std::unique_ptr<IScalarBuilder> MakeScalarBuilder(const ITypeInfoHelper& typeInfoHelper, const TType* type) {
diff --git a/ydb/library/yql/public/udf/arrow/block_item_comparator.h b/ydb/library/yql/public/udf/arrow/block_item_comparator.h
index b0a4843768e..3044f8d4e3d 100644
--- a/ydb/library/yql/public/udf/arrow/block_item_comparator.h
+++ b/ydb/library/yql/public/udf/arrow/block_item_comparator.h
@@ -126,9 +126,15 @@ public:
     }
 };
 
-template <typename TStringType, bool Nullable>
-class TStringBlockItemComparator : public TBlockItemComparatorBase<TStringBlockItemComparator<TStringType, Nullable>, Nullable> {
+template <typename TStringType, bool Nullable, NUdf::EPgStringType PgString>
+class TStringBlockItemComparator : public TBlockItemComparatorBase<TStringBlockItemComparator<TStringType, Nullable, PgString>, Nullable> {
 public:
+    void SetPgBuilder(const IPgBuilder* pgBuilder, i32 typeLen, ui32 pgTypeId) {
+        Y_UNUSED(pgBuilder);
+        Y_UNUSED(typeLen);
+        Y_UNUSED(pgTypeId);
+    }
+
     i64 DoCompare(TBlockItem lhs, TBlockItem rhs) const {
         return lhs.AsStringRef().Compare(rhs.AsStringRef());
     }
@@ -218,13 +224,13 @@ struct TComparatorTraits {
     using TTuple = TTupleBlockItemComparator<Nullable>;
     template <typename T, bool Nullable>
     using TFixedSize = TFixedSizeBlockItemComparator<T, Nullable>;
-    template <typename TStringType, bool Nullable>
-    using TStrings = TStringBlockItemComparator<TStringType, Nullable>;
+    template <typename TStringType, bool Nullable, NUdf::EPgStringType PgString>
+    using TStrings = TStringBlockItemComparator<TStringType, Nullable, PgString>;
     using TExtOptional = TExternalOptionalBlockItemComparator;
 };
 
 inline std::unique_ptr<IBlockItemComparator> MakeBlockItemComparator(const ITypeInfoHelper& typeInfoHelper, const TType* type) {
-    return MakeBlockReaderImpl<TComparatorTraits>(typeInfoHelper, type);
+    return MakeBlockReaderImpl<TComparatorTraits>(typeInfoHelper, type, nullptr);
 }
 
 }
diff --git a/ydb/library/yql/public/udf/arrow/block_reader.h b/ydb/library/yql/public/udf/arrow/block_reader.h
index 5302e8ffc43..55cc8e60d0d 100644
--- a/ydb/library/yql/public/udf/arrow/block_reader.h
+++ b/ydb/library/yql/public/udf/arrow/block_reader.h
@@ -6,6 +6,7 @@
 #include <arrow/datum.h>
 
 #include <ydb/library/yql/public/udf/udf_type_inspection.h>
+#include <ydb/library/yql/public/udf/udf_value_builder.h>
 
 namespace NYql {
 namespace NUdf {
@@ -73,11 +74,17 @@ public:
     }
 };
 
-template<typename TStringType, bool Nullable>
+template<typename TStringType, bool Nullable, EPgStringType PgString = EPgStringType::None>
 class TStringBlockReader final : public IBlockReader {
 public:
     using TOffset = typename TStringType::offset_type;
 
+    void SetPgBuilder(const IPgBuilder* pgBuilder, i32 typeLen, ui32 pgTypeId) {
+        Y_UNUSED(pgBuilder);
+        Y_UNUSED(typeLen);
+        Y_UNUSED(pgTypeId);
+    }
+
     TBlockItem GetItem(const arrow::ArrayData& data, size_t index) final {
         Y_VERIFY_DEBUG(data.buffers.size() == 3);
         if constexpr (Nullable) {
@@ -258,8 +265,8 @@ struct TReaderTraits {
     using TTuple = TTupleBlockReader<Nullable>;
     template <typename T, bool Nullable>
     using TFixedSize = TFixedSizeBlockReader<T, Nullable>;
-    template <typename TStringType, bool Nullable>
-    using TStrings = TStringBlockReader<TStringType, Nullable>;
+    template <typename TStringType, bool Nullable, EPgStringType PgString>
+    using TStrings = TStringBlockReader<TStringType, Nullable, PgString>;
     using TExtOptional = TExternalOptionalBlockReader;
 };
 
@@ -281,17 +288,17 @@ std::unique_ptr<typename TTraits::TResult> MakeFixedSizeBlockReaderImpl(bool isO
     }
 }
 
-template <typename TTraits, typename T>
+template <typename TTraits, typename T, EPgStringType PgString>
 std::unique_ptr<typename TTraits::TResult> MakeStringBlockReaderImpl(bool isOptional) {
     if (isOptional) {
-        return std::make_unique<typename TTraits::template TStrings<T, true>>();
+        return std::make_unique<typename TTraits::template TStrings<T, true, PgString>>();
     } else {
-        return std::make_unique<typename TTraits::template TStrings<T, false>>();
+        return std::make_unique<typename TTraits::template TStrings<T, false, PgString>>();
     }
 }
 
 template <typename TTraits>
-std::unique_ptr<typename TTraits::TResult> MakeBlockReaderImpl(const ITypeInfoHelper& typeInfoHelper, const TType* type) {
+std::unique_ptr<typename TTraits::TResult> MakeBlockReaderImpl(const ITypeInfoHelper& typeInfoHelper, const TType* type, const IPgBuilder* pgBuilder) {
     const TType* unpacked = type;
     TOptionalTypeInspector typeOpt(typeInfoHelper, type);
     bool isOptional = false;
@@ -301,7 +308,8 @@ std::unique_ptr<typename TTraits::TResult> MakeBlockReaderImpl(const ITypeInfoHe
     }
 
     TOptionalTypeInspector unpackedOpt(typeInfoHelper, unpacked);
-    if (unpackedOpt) {
+    TPgTypeInspector unpackedPg(typeInfoHelper, unpacked);
+    if (unpackedOpt || typeOpt && unpackedPg) {
         // at least 2 levels of optionals
         ui32 nestLevel = 0;
         auto currentType = type;
@@ -317,7 +325,7 @@ std::unique_ptr<typename TTraits::TResult> MakeBlockReaderImpl(const ITypeInfoHe
             }
         }
 
-        auto reader = MakeBlockReaderImpl<TTraits>(typeInfoHelper, previousType);
+        auto reader = MakeBlockReaderImpl<TTraits>(typeInfoHelper, previousType, pgBuilder);
         for (ui32 i = 1; i < nestLevel; ++i) {
             reader = std::make_unique<typename TTraits::TExtOptional>(std::move(reader));
         }
@@ -332,7 +340,7 @@ std::unique_ptr<typename TTraits::TResult> MakeBlockReaderImpl(const ITypeInfoHe
     if (typeTuple) {
         TVector<std::unique_ptr<typename TTraits::TResult>> children;
         for (ui32 i = 0; i < typeTuple.GetElementsCount(); ++i) {
-            children.emplace_back(MakeBlockReaderImpl<TTraits>(typeInfoHelper, typeTuple.GetElementType(i)));
+            children.emplace_back(MakeBlockReaderImpl<TTraits>(typeInfoHelper, typeTuple.GetElementType(i), pgBuilder));
         }
 
         return MakeTupleBlockReaderImpl<TTraits>(isOptional, std::move(children));
@@ -368,19 +376,37 @@ std::unique_ptr<typename TTraits::TResult> MakeBlockReaderImpl(const ITypeInfoHe
         case NUdf::EDataSlot::Double:
             return MakeFixedSizeBlockReaderImpl<TTraits, double>(isOptional);
         case NUdf::EDataSlot::String:
-            return MakeStringBlockReaderImpl<TTraits, arrow::BinaryType>(isOptional);
+            return MakeStringBlockReaderImpl<TTraits, arrow::BinaryType, EPgStringType::None>(isOptional);
         case NUdf::EDataSlot::Utf8:
-            return MakeStringBlockReaderImpl<TTraits, arrow::StringType>(isOptional);
+            return MakeStringBlockReaderImpl<TTraits, arrow::StringType, EPgStringType::None>(isOptional);
         default:
             Y_ENSURE(false, "Unsupported data slot");
         }
     }
 
+    TPgTypeInspector typePg(typeInfoHelper, type);
+    if (typePg) {
+        auto desc = typeInfoHelper.FindPgTypeDescription(typePg.GetTypeId());
+        if (desc->PassByValue) {
+            return MakeFixedSizeBlockReaderImpl<TTraits, ui64>(true);
+        } else {
+            if (desc->Typelen == -1) {
+                auto ret = std::make_unique<typename TTraits::template TStrings<arrow::BinaryType, true, EPgStringType::Text>>();
+                ret->SetPgBuilder(pgBuilder, desc->Typelen, typePg.GetTypeId());
+                return ret;
+            } else {
+                auto ret = std::make_unique<typename TTraits::template TStrings<arrow::BinaryType, true, EPgStringType::CString>>();
+                ret->SetPgBuilder(pgBuilder, desc->Typelen, typePg.GetTypeId());
+                return ret;
+            }
+        }
+    }
+
     Y_ENSURE(false, "Unsupported type");
 }
 
 inline std::unique_ptr<IBlockReader> MakeBlockReader(const ITypeInfoHelper& typeInfoHelper, const TType* type) {
-    return MakeBlockReaderImpl<TReaderTraits>(typeInfoHelper, type);
+    return MakeBlockReaderImpl<TReaderTraits>(typeInfoHelper, type, nullptr);
 }
 
 inline void UpdateBlockItemSerializeProps(const ITypeInfoHelper& typeInfoHelper, const TType* type, TBlockItemSerializeProps& props) {
diff --git a/ydb/library/yql/public/udf/arrow/udf_arrow_helpers.h b/ydb/library/yql/public/udf/arrow/udf_arrow_helpers.h
index 50f33a629e5..ed0755f46df 100644
--- a/ydb/library/yql/public/udf/arrow/udf_arrow_helpers.h
+++ b/ydb/library/yql/public/udf/arrow/udf_arrow_helpers.h
@@ -25,11 +25,12 @@ using TExec = arrow::Status(*)(arrow::compute::KernelContext*, const arrow::comp
 
 class TUdfKernelState : public arrow::compute::KernelState {
 public:
-    TUdfKernelState(const TVector<const TType*>& argTypes, const TType* outputType, bool onlyScalars, const ITypeInfoHelper* typeInfoHelper)
+    TUdfKernelState(const TVector<const TType*>& argTypes, const TType* outputType, bool onlyScalars, const ITypeInfoHelper* typeInfoHelper, const IPgBuilder& pgBuilder)
         : ArgTypes_(argTypes)
         , OutputType_(outputType)
         , OnlyScalars_(onlyScalars)
         , TypeInfoHelper_(typeInfoHelper)
+        , PgBuilder_(pgBuilder)
     {
         Readers_.resize(ArgTypes_.size());
     }
@@ -45,7 +46,7 @@ public:
     IArrayBuilder& GetArrayBuilder() {
         Y_ENSURE(!OnlyScalars_);
         if (!ArrayBuilder_) {
-            ArrayBuilder_ = MakeArrayBuilder(*TypeInfoHelper_, OutputType_, *arrow::default_memory_pool(), TypeInfoHelper_->GetMaxBlockLength(OutputType_));
+            ArrayBuilder_ = MakeArrayBuilder(*TypeInfoHelper_, OutputType_, *arrow::default_memory_pool(), TypeInfoHelper_->GetMaxBlockLength(OutputType_), &PgBuilder_);
         }
 
         return *ArrayBuilder_;
@@ -65,6 +66,7 @@ private:
     const TType* OutputType_;
     const bool OnlyScalars_;
     const ITypeInfoHelper* TypeInfoHelper_;
+    const IPgBuilder& PgBuilder_;  
     TVector<std::unique_ptr<IBlockReader>> Readers_;
     std::unique_ptr<IArrayBuilder> ArrayBuilder_;
     std::unique_ptr<IScalarBuilder> ScalarBuilder_;
@@ -144,7 +146,7 @@ public:
                 }
             }
 
-            TUdfKernelState kernelState(ArgTypes_, OutputType_, OnlyScalars_, TypeInfoHelper_.Get());
+            TUdfKernelState kernelState(ArgTypes_, OutputType_, OnlyScalars_, TypeInfoHelper_.Get(), valueBuilder->GetPgBuilder());
             arrow::compute::ExecContext execContext;
             arrow::compute::KernelContext kernelContext(&execContext);
             kernelContext.SetState(&kernelState);
diff --git a/ydb/library/yql/public/udf/arrow/util.h b/ydb/library/yql/public/udf/arrow/util.h
index 06651f259b7..ae3e103c839 100644
--- a/ydb/library/yql/public/udf/arrow/util.h
+++ b/ydb/library/yql/public/udf/arrow/util.h
@@ -13,6 +13,12 @@
 namespace NYql {
 namespace NUdf {
 
+enum class EPgStringType {
+    None,
+    Text,
+    CString
+};
+
 std::shared_ptr<arrow::Buffer> AllocateBitmapWithReserve(size_t bitCount, arrow::MemoryPool* pool);
 std::shared_ptr<arrow::Buffer> MakeDenseBitmap(const ui8* srcSparse, size_t len, arrow::MemoryPool* pool);
 std::shared_ptr<arrow::Buffer> MakeDenseBitmapNegate(const ui8* srcSparse, size_t len, arrow::MemoryPool* pool);
diff --git a/ydb/library/yql/public/udf/udf_value_builder.h b/ydb/library/yql/public/udf/udf_value_builder.h
index d04498b7085..bc384adb9b3 100644
--- a/ydb/library/yql/public/udf/udf_value_builder.h
+++ b/ydb/library/yql/public/udf/udf_value_builder.h
@@ -110,9 +110,9 @@ UDF_ASSERT_TYPE_SIZE(IDateBuilder, 8);
 ///////////////////////////////////////////////////////////////////////////////
 // IPgBuilder
 ///////////////////////////////////////////////////////////////////////////////
-class IPgBuilder {
+class IPgBuilder1 {
 public:
-    virtual ~IPgBuilder() {}
+    virtual ~IPgBuilder1() = default;
     // returns Null in case of text format parsing error, error message passed via 'error' arg
     virtual TUnboxedValue ValueFromText(ui32 typeId, const TStringRef& value, TStringValue& error) const = 0;
 
@@ -128,6 +128,23 @@ public:
     // targetTypeId is required for diagnostic only in debug mode
     virtual TUnboxedValue NewString(i32 typeLen, ui32 targetTypeId, TStringRef data) const = 0;
 };
+
+#if UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 31)
+class IPgBuilder2: public IPgBuilder1
+{
+public:
+    virtual TStringRef AsCStringBuffer(const TUnboxedValue& value) const = 0;
+    virtual TStringRef AsTextBuffer(const TUnboxedValue& value) const = 0;
+};
+#endif
+
+
+#if UDF_ABI_COMPATIBILITY_VERSION_CURRENT >= UDF_ABI_COMPATIBILITY_VERSION(2, 31)
+class IPgBuilder: public IPgBuilder2 {};
+#else
+class IPgBuilder: public IPgBuilder1 {};
+#endif
+
 UDF_ASSERT_TYPE_SIZE(IPgBuilder, 8);
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/ydb/library/yql/public/udf/udf_version.h b/ydb/library/yql/public/udf/udf_version.h
index 60a7ea03850..36023d6ecab 100644
--- a/ydb/library/yql/public/udf/udf_version.h
+++ b/ydb/library/yql/public/udf/udf_version.h
@@ -7,7 +7,7 @@ namespace NYql {
 namespace NUdf {
 
 #define CURRENT_UDF_ABI_VERSION_MAJOR 2
-#define CURRENT_UDF_ABI_VERSION_MINOR 30
+#define CURRENT_UDF_ABI_VERSION_MINOR 31
 #define CURRENT_UDF_ABI_VERSION_PATCH 0
 
 #ifdef USE_CURRENT_UDF_ABI_VERSION
diff --git a/ydb/library/yql/sql/pg_dummy/pg_sql_dummy.cpp b/ydb/library/yql/sql/pg_dummy/pg_sql_dummy.cpp
index 017388afce0..66e68d5db1c 100644
--- a/ydb/library/yql/sql/pg_dummy/pg_sql_dummy.cpp
+++ b/ydb/library/yql/sql/pg_dummy/pg_sql_dummy.cpp
@@ -276,6 +276,16 @@ public:
         Y_UNUSED(data);
         ythrow yexception() << "TPgDummyBuilder::NewString does nothing";
     }
+
+    NUdf::TStringRef AsCStringBuffer(const NUdf::TUnboxedValue& value) const override {
+        Y_UNUSED(value);
+        ythrow yexception() << "TPgDummyBuilder::AsCStringBuffer does nothing";
+    }
+
+    NUdf::TStringRef AsTextBuffer(const NUdf::TUnboxedValue& value) const override {
+        Y_UNUSED(value);
+        ythrow yexception() << "TPgDummyBuilder::AsTextBuffer does nothing";
+    }
 };
 
 std::unique_ptr<NUdf::IPgBuilder> CreatePgBuilder() {
diff --git a/ydb/library/yql/udfs/common/datetime2/CMakeLists.darwin-x86_64.txt b/ydb/library/yql/udfs/common/datetime2/CMakeLists.darwin-x86_64.txt
index 6f8d710a7c4..91de393c57b 100644
--- a/ydb/library/yql/udfs/common/datetime2/CMakeLists.darwin-x86_64.txt
+++ b/ydb/library/yql/udfs/common/datetime2/CMakeLists.darwin-x86_64.txt
@@ -23,7 +23,7 @@ target_link_libraries(datetime2_udf INTERFACE
 add_global_library_for(datetime2_udf.global datetime2_udf)
 target_compile_options(datetime2_udf.global PRIVATE
   -DUDF_ABI_VERSION_MAJOR=2
-  -DUDF_ABI_VERSION_MINOR=29
+  -DUDF_ABI_VERSION_MINOR=31
   -DUDF_ABI_VERSION_PATCH=0
 )
 target_link_libraries(datetime2_udf.global PUBLIC
diff --git a/ydb/library/yql/udfs/common/datetime2/CMakeLists.linux-aarch64.txt b/ydb/library/yql/udfs/common/datetime2/CMakeLists.linux-aarch64.txt
index 33e286d79f1..6b5c6fcef0e 100644
--- a/ydb/library/yql/udfs/common/datetime2/CMakeLists.linux-aarch64.txt
+++ b/ydb/library/yql/udfs/common/datetime2/CMakeLists.linux-aarch64.txt
@@ -24,7 +24,7 @@ target_link_libraries(datetime2_udf INTERFACE
 add_global_library_for(datetime2_udf.global datetime2_udf)
 target_compile_options(datetime2_udf.global PRIVATE
   -DUDF_ABI_VERSION_MAJOR=2
-  -DUDF_ABI_VERSION_MINOR=29
+  -DUDF_ABI_VERSION_MINOR=31
   -DUDF_ABI_VERSION_PATCH=0
 )
 target_link_libraries(datetime2_udf.global PUBLIC
diff --git a/ydb/library/yql/udfs/common/datetime2/CMakeLists.linux-x86_64.txt b/ydb/library/yql/udfs/common/datetime2/CMakeLists.linux-x86_64.txt
index 33e286d79f1..6b5c6fcef0e 100644
--- a/ydb/library/yql/udfs/common/datetime2/CMakeLists.linux-x86_64.txt
+++ b/ydb/library/yql/udfs/common/datetime2/CMakeLists.linux-x86_64.txt
@@ -24,7 +24,7 @@ target_link_libraries(datetime2_udf INTERFACE
 add_global_library_for(datetime2_udf.global datetime2_udf)
 target_compile_options(datetime2_udf.global PRIVATE
   -DUDF_ABI_VERSION_MAJOR=2
-  -DUDF_ABI_VERSION_MINOR=29
+  -DUDF_ABI_VERSION_MINOR=31
   -DUDF_ABI_VERSION_PATCH=0
 )
 target_link_libraries(datetime2_udf.global PUBLIC
diff --git a/ydb/library/yql/udfs/common/datetime2/CMakeLists.windows-x86_64.txt b/ydb/library/yql/udfs/common/datetime2/CMakeLists.windows-x86_64.txt
index 6f8d710a7c4..91de393c57b 100644
--- a/ydb/library/yql/udfs/common/datetime2/CMakeLists.windows-x86_64.txt
+++ b/ydb/library/yql/udfs/common/datetime2/CMakeLists.windows-x86_64.txt
@@ -23,7 +23,7 @@ target_link_libraries(datetime2_udf INTERFACE
 add_global_library_for(datetime2_udf.global datetime2_udf)
 target_compile_options(datetime2_udf.global PRIVATE
   -DUDF_ABI_VERSION_MAJOR=2
-  -DUDF_ABI_VERSION_MINOR=29
+  -DUDF_ABI_VERSION_MINOR=31
   -DUDF_ABI_VERSION_PATCH=0
 )
 target_link_libraries(datetime2_udf.global PUBLIC
diff --git a/ydb/library/yql/udfs/common/url_base/CMakeLists.darwin-x86_64.txt b/ydb/library/yql/udfs/common/url_base/CMakeLists.darwin-x86_64.txt
index d6161089ba3..64b76ee37f1 100644
--- a/ydb/library/yql/udfs/common/url_base/CMakeLists.darwin-x86_64.txt
+++ b/ydb/library/yql/udfs/common/url_base/CMakeLists.darwin-x86_64.txt
@@ -20,7 +20,7 @@ target_link_libraries(url_udf INTERFACE
 add_global_library_for(url_udf.global url_udf)
 target_compile_options(url_udf.global PRIVATE
   -DUDF_ABI_VERSION_MAJOR=2
-  -DUDF_ABI_VERSION_MINOR=29
+  -DUDF_ABI_VERSION_MINOR=31
   -DUDF_ABI_VERSION_PATCH=0
 )
 target_link_libraries(url_udf.global PUBLIC
diff --git a/ydb/library/yql/udfs/common/url_base/CMakeLists.linux-aarch64.txt b/ydb/library/yql/udfs/common/url_base/CMakeLists.linux-aarch64.txt
index dc4b9a0dbac..91a0105d1fd 100644
--- a/ydb/library/yql/udfs/common/url_base/CMakeLists.linux-aarch64.txt
+++ b/ydb/library/yql/udfs/common/url_base/CMakeLists.linux-aarch64.txt
@@ -21,7 +21,7 @@ target_link_libraries(url_udf INTERFACE
 add_global_library_for(url_udf.global url_udf)
 target_compile_options(url_udf.global PRIVATE
   -DUDF_ABI_VERSION_MAJOR=2
-  -DUDF_ABI_VERSION_MINOR=29
+  -DUDF_ABI_VERSION_MINOR=31
   -DUDF_ABI_VERSION_PATCH=0
 )
 target_link_libraries(url_udf.global PUBLIC
diff --git a/ydb/library/yql/udfs/common/url_base/CMakeLists.linux-x86_64.txt b/ydb/library/yql/udfs/common/url_base/CMakeLists.linux-x86_64.txt
index dc4b9a0dbac..91a0105d1fd 100644
--- a/ydb/library/yql/udfs/common/url_base/CMakeLists.linux-x86_64.txt
+++ b/ydb/library/yql/udfs/common/url_base/CMakeLists.linux-x86_64.txt
@@ -21,7 +21,7 @@ target_link_libraries(url_udf INTERFACE
 add_global_library_for(url_udf.global url_udf)
 target_compile_options(url_udf.global PRIVATE
   -DUDF_ABI_VERSION_MAJOR=2
-  -DUDF_ABI_VERSION_MINOR=29
+  -DUDF_ABI_VERSION_MINOR=31
   -DUDF_ABI_VERSION_PATCH=0
 )
 target_link_libraries(url_udf.global PUBLIC
diff --git a/ydb/library/yql/udfs/common/url_base/CMakeLists.windows-x86_64.txt b/ydb/library/yql/udfs/common/url_base/CMakeLists.windows-x86_64.txt
index d6161089ba3..64b76ee37f1 100644
--- a/ydb/library/yql/udfs/common/url_base/CMakeLists.windows-x86_64.txt
+++ b/ydb/library/yql/udfs/common/url_base/CMakeLists.windows-x86_64.txt
@@ -20,7 +20,7 @@ target_link_libraries(url_udf INTERFACE
 add_global_library_for(url_udf.global url_udf)
 target_compile_options(url_udf.global PRIVATE
   -DUDF_ABI_VERSION_MAJOR=2
-  -DUDF_ABI_VERSION_MINOR=29
+  -DUDF_ABI_VERSION_MINOR=31
   -DUDF_ABI_VERSION_PATCH=0
 )
 target_link_libraries(url_udf.global PUBLIC
diff --git a/ydb/library/yql/udfs/common/url_base/lib/CMakeLists.darwin-x86_64.txt b/ydb/library/yql/udfs/common/url_base/lib/CMakeLists.darwin-x86_64.txt
index cf9f8d6bdae..022e8f5f575 100644
--- a/ydb/library/yql/udfs/common/url_base/lib/CMakeLists.darwin-x86_64.txt
+++ b/ydb/library/yql/udfs/common/url_base/lib/CMakeLists.darwin-x86_64.txt
@@ -10,7 +10,7 @@
 add_library(common-url_base-lib)
 target_compile_options(common-url_base-lib PRIVATE
   -DUDF_ABI_VERSION_MAJOR=2
-  -DUDF_ABI_VERSION_MINOR=29
+  -DUDF_ABI_VERSION_MINOR=31
   -DUDF_ABI_VERSION_PATCH=0
 )
 target_link_libraries(common-url_base-lib PUBLIC
diff --git a/ydb/library/yql/udfs/common/url_base/lib/CMakeLists.linux-aarch64.txt b/ydb/library/yql/udfs/common/url_base/lib/CMakeLists.linux-aarch64.txt
index cdc5b23fcb4..f76c72fac0a 100644
--- a/ydb/library/yql/udfs/common/url_base/lib/CMakeLists.linux-aarch64.txt
+++ b/ydb/library/yql/udfs/common/url_base/lib/CMakeLists.linux-aarch64.txt
@@ -10,7 +10,7 @@
 add_library(common-url_base-lib)
 target_compile_options(common-url_base-lib PRIVATE
   -DUDF_ABI_VERSION_MAJOR=2
-  -DUDF_ABI_VERSION_MINOR=29
+  -DUDF_ABI_VERSION_MINOR=31
   -DUDF_ABI_VERSION_PATCH=0
 )
 target_link_libraries(common-url_base-lib PUBLIC
diff --git a/ydb/library/yql/udfs/common/url_base/lib/CMakeLists.linux-x86_64.txt b/ydb/library/yql/udfs/common/url_base/lib/CMakeLists.linux-x86_64.txt
index cdc5b23fcb4..f76c72fac0a 100644
--- a/ydb/library/yql/udfs/common/url_base/lib/CMakeLists.linux-x86_64.txt
+++ b/ydb/library/yql/udfs/common/url_base/lib/CMakeLists.linux-x86_64.txt
@@ -10,7 +10,7 @@
 add_library(common-url_base-lib)
 target_compile_options(common-url_base-lib PRIVATE
   -DUDF_ABI_VERSION_MAJOR=2
-  -DUDF_ABI_VERSION_MINOR=29
+  -DUDF_ABI_VERSION_MINOR=31
   -DUDF_ABI_VERSION_PATCH=0
 )
 target_link_libraries(common-url_base-lib PUBLIC
diff --git a/ydb/library/yql/udfs/common/url_base/lib/CMakeLists.windows-x86_64.txt b/ydb/library/yql/udfs/common/url_base/lib/CMakeLists.windows-x86_64.txt
index cf9f8d6bdae..022e8f5f575 100644
--- a/ydb/library/yql/udfs/common/url_base/lib/CMakeLists.windows-x86_64.txt
+++ b/ydb/library/yql/udfs/common/url_base/lib/CMakeLists.windows-x86_64.txt
@@ -10,7 +10,7 @@
 add_library(common-url_base-lib)
 target_compile_options(common-url_base-lib PRIVATE
   -DUDF_ABI_VERSION_MAJOR=2
-  -DUDF_ABI_VERSION_MINOR=29
+  -DUDF_ABI_VERSION_MINOR=31
   -DUDF_ABI_VERSION_PATCH=0
 )
 target_link_libraries(common-url_base-lib PUBLIC