Slow versions of PG kernels under sanitizers or DEBUG build

22 files changed, 12375 insertions, 9661 deletions

diff --git a/ydb/library/yql/parser/pg_wrapper/CMakeLists.darwin-x86_64.txt b/ydb/library/yql/parser/pg_wrapper/CMakeLists.darwin-x86_64.txt
index 84678ff3689..fba1dca5f7e 100644
--- a/ydb/library/yql/parser/pg_wrapper/CMakeLists.darwin-x86_64.txt
+++ b/ydb/library/yql/parser/pg_wrapper/CMakeLists.darwin-x86_64.txt
@@ -14,6 +14,7 @@ add_library(yql-parser-pg_wrapper)
 target_compile_options(yql-parser-pg_wrapper PRIVATE
   -DHAVE__GET_CPUID=1
   -DUSE_SSE42_CRC32C_WITH_RUNTIME_CHECK=1
+  -DUSE_SLOW_PG_KERNELS
   -DDLSUFFIX=".so"
   -Wno-ignored-attributes
   -Wno-unused-parameter
diff --git a/ydb/library/yql/parser/pg_wrapper/CMakeLists.linux-aarch64.txt b/ydb/library/yql/parser/pg_wrapper/CMakeLists.linux-aarch64.txt
index 6ed349d3a17..23798855ab7 100644
--- a/ydb/library/yql/parser/pg_wrapper/CMakeLists.linux-aarch64.txt
+++ b/ydb/library/yql/parser/pg_wrapper/CMakeLists.linux-aarch64.txt
@@ -12,6 +12,7 @@ add_subdirectory(ut)
 
 add_library(yql-parser-pg_wrapper)
 target_compile_options(yql-parser-pg_wrapper PRIVATE
+  -DUSE_SLOW_PG_KERNELS
   -DDLSUFFIX=".so"
   -Wno-ignored-attributes
   -Wno-unused-parameter
diff --git a/ydb/library/yql/parser/pg_wrapper/CMakeLists.linux-x86_64.txt b/ydb/library/yql/parser/pg_wrapper/CMakeLists.linux-x86_64.txt
index 90676682359..af9c454bfb7 100644
--- a/ydb/library/yql/parser/pg_wrapper/CMakeLists.linux-x86_64.txt
+++ b/ydb/library/yql/parser/pg_wrapper/CMakeLists.linux-x86_64.txt
@@ -14,6 +14,7 @@ add_library(yql-parser-pg_wrapper)
 target_compile_options(yql-parser-pg_wrapper PRIVATE
   -DHAVE__GET_CPUID=1
   -DUSE_SSE42_CRC32C_WITH_RUNTIME_CHECK=1
+  -DUSE_SLOW_PG_KERNELS
   -DDLSUFFIX=".so"
   -Wno-ignored-attributes
   -Wno-unused-parameter
diff --git a/ydb/library/yql/parser/pg_wrapper/CMakeLists.windows-x86_64.txt b/ydb/library/yql/parser/pg_wrapper/CMakeLists.windows-x86_64.txt
index 4a83ff52502..6b27385bbda 100644
--- a/ydb/library/yql/parser/pg_wrapper/CMakeLists.windows-x86_64.txt
+++ b/ydb/library/yql/parser/pg_wrapper/CMakeLists.windows-x86_64.txt
@@ -15,6 +15,7 @@ add_library(yql-parser-pg_wrapper)
 target_compile_options(yql-parser-pg_wrapper PRIVATE
   -DHAVE__GET_CPUID=1
   -DUSE_SSE42_CRC32C_WITH_RUNTIME_CHECK=1
+  -DUSE_SLOW_PG_KERNELS
   -DDLSUFFIX=".so"
   -Wno-ignored-attributes
   -Wno-unused-parameter
diff --git a/ydb/library/yql/parser/pg_wrapper/arrow.h b/ydb/library/yql/parser/pg_wrapper/arrow.h
index b93b73e5899..35bd8c8d83e 100644
--- a/ydb/library/yql/parser/pg_wrapper/arrow.h
+++ b/ydb/library/yql/parser/pg_wrapper/arrow.h
@@ -8,6 +8,8 @@
 
 #include "arena_ctx.h"
 
+#include <functional>
+
 extern "C" {
 #include "postgres.h"
 #include "fmgr.h"
@@ -25,11 +27,23 @@ struct TPgKernelState : arrow::compute::KernelState {
     bool IsCStringResult;
 };
 
-template <Datum (*PgFunc)(FunctionCallInfo)>
+template <PGFunction PgFunc>
 struct TPgDirectFunc {
-    Datum operator()(FunctionCallInfo info) {
+    Datum operator()(FunctionCallInfo info) const {
+        return PgFunc(info);
+    }
+};
+
+struct TPgIndirectFunc {
+    TPgIndirectFunc(PGFunction pgFunc)
+        : PgFunc(pgFunc)
+    {}
+
+    Datum operator()(FunctionCallInfo info) const {
         return PgFunc(info);
     }
+
+    PGFunction PgFunc;
 };
 
 template <bool HasNulls, bool IsFixed>
@@ -106,124 +120,208 @@ enum class EScalarArgBinary {
     Second
 };
 
-template <typename TFunc, bool IsStrict, bool IsFixedResult, bool HasScalars, bool HasNulls, typename TArgsPolicy, EScalarArgBinary ScalarArgBinary, typename TBuilder>
-Y_NO_INLINE arrow::Datum GenericExecImpl(const arrow::compute::ExecBatch& batch, size_t length, const TPgKernelState& state, TBuilder& builder) {
-    LOCAL_FCINFO(fcinfo, FUNC_MAX_ARGS);    
-	fcinfo->flinfo = state.flinfo;
-	fcinfo->context = state.context;
-	fcinfo->resultinfo = state.resultinfo;
-	fcinfo->fncollation = state.fncollation;
-    fcinfo->nargs = batch.values.size();    
-
-    std::array<NullableDatum, TArgsPolicy::IsFixedArg.size()> scalars;
-    std::array<bool, TArgsPolicy::IsFixedArg.size()> isScalar;
-    std::array<ui64, TArgsPolicy::IsFixedArg.size()> offsets;
-    std::array<const ui8*, TArgsPolicy::IsFixedArg.size()> validMasks;
-    std::array<ui64, TArgsPolicy::IsFixedArg.size()> validOffsetMask;
-    ui8 fakeValidByte = 0xFF;
-    std::array<const ui64*, TArgsPolicy::IsFixedArg.size()> fixedArrays;
-    std::array<const ui32*, TArgsPolicy::IsFixedArg.size()> stringOffsetsArrays;
-    std::array<const ui8*, TArgsPolicy::IsFixedArg.size()> stringDataArrays;
-    if constexpr (!TArgsPolicy::VarArgs) {
-        for (size_t j = 0; j < TArgsPolicy::IsFixedArg.size(); ++j) {
-            isScalar[j] = batch.values[j].is_scalar();
-            if (isScalar[j]) {
-                const auto& scalar = *batch.values[j].scalar();
-                if (!scalar.is_valid) {
-                    scalars[j].isnull = true;
+struct TDefaultArgsPolicy {
+    static constexpr bool VarArgs = true;
+    static constexpr std::array<bool, 0> IsFixedArg = {};
+};
+
+extern "C" TPgKernelState& GetPGKernelState(arrow::compute::KernelContext* ctx);
+
+template <typename TFunc, bool IsStrict, bool IsFixedResult, typename TArgsPolicy = TDefaultArgsPolicy>
+struct TGenericExec {
+    TGenericExec(TFunc func)
+        : Func(func)
+    {}
+
+    Y_NO_INLINE arrow::Status operator()(arrow::compute::KernelContext* ctx, const arrow::compute::ExecBatch& batch, arrow::Datum* res) const {
+        const auto& state = GetPGKernelState(ctx);
+        if constexpr (!TArgsPolicy::VarArgs) {
+            Y_ENSURE(batch.values.size() == TArgsPolicy::IsFixedArg.size());
+            Y_ENSURE(state.IsFixedArg.size() == TArgsPolicy::IsFixedArg.size());
+            for (ui32 i = 0; i < TArgsPolicy::IsFixedArg.size(); ++i) {
+                Y_ENSURE(state.IsFixedArg[i] == TArgsPolicy::IsFixedArg[i]);
+            }
+        }
+
+        size_t length = 1;
+        bool hasNulls = false;
+        bool hasArrays = false;
+        bool hasScalars = false;
+        for (const auto& v : batch.values) {
+            if (v.is_array()) {
+                length = v.array()->length;
+                if (v.array()->GetNullCount() > 0) {
+                    hasNulls = true;
+                }
+
+                hasArrays = true;
+            } else {
+                hasScalars = true;
+                if (!v.scalar()->is_valid) {
+                    hasNulls = true;
+                }
+            }
+        }
+
+        Y_ENSURE(hasArrays);
+        Y_ENSURE(state.flinfo->fn_strict == IsStrict);
+        Y_ENSURE(state.IsFixedResult == IsFixedResult);
+        TArenaMemoryContext arena;
+        Dispatch1(hasScalars, hasNulls, ctx, batch, length, state, res);
+        return arrow::Status::OK();
+    }
+
+    Y_NO_INLINE void Dispatch1(bool hasScalars, bool hasNulls, arrow::compute::KernelContext* ctx,
+        const arrow::compute::ExecBatch& batch, size_t length, const TPgKernelState& state, arrow::Datum* res) const {
+        if (hasScalars) {
+            if (hasNulls) {
+                if constexpr (IsFixedResult) {
+                    NUdf::TFixedSizeArrayBuilder<ui64, true> builder(NKikimr::NMiniKQL::TTypeInfoHelper(), arrow::uint64(), *ctx->memory_pool(), length);
+                    *res = Dispatch2<true, true>(batch, length, state, builder);
                 } else {
-                    scalars[j].isnull = false;
-                    if (TArgsPolicy::IsFixedArg[j]) {
-                        scalars[j].value = (Datum)*static_cast<const ui64*>(arrow::internal::checked_cast<const arrow::internal::PrimitiveScalarBase&>(scalar).data());
-                    } else {
-                        auto buffer = arrow::internal::checked_cast<const arrow::BaseBinaryScalar&>(scalar).value;
-                        scalars[j].value = (Datum)buffer->data();
-                    }
+                    NUdf::TStringArrayBuilder<arrow::BinaryType, true, NUdf::EPgStringType::None> builder(NKikimr::NMiniKQL::TTypeInfoHelper(), arrow::uint64(), *ctx->memory_pool(), length);
+                    *res = Dispatch2<true, true>(batch, length, state, builder);
                 }
             } else {
-                const auto& array = *batch.values[j].array();
-                offsets[j] = array.offset;
-                validMasks[j] = array.GetValues<ui8>(0, 0);
-                if (validMasks[j]) {
-                    validOffsetMask[j] = ~0ull;
+                if constexpr (IsFixedResult) {
+                    NUdf::TFixedSizeArrayBuilder<ui64, true> builder(NKikimr::NMiniKQL::TTypeInfoHelper(), arrow::uint64(), *ctx->memory_pool(), length);
+                    *res = Dispatch2<true, false>(batch, length, state, builder);
                 } else {
-                    validOffsetMask[j] = 0ull;
-                    validMasks[j] = &fakeValidByte;                    
+                    NUdf::TStringArrayBuilder<arrow::BinaryType, true, NUdf::EPgStringType::None> builder(NKikimr::NMiniKQL::TTypeInfoHelper(), arrow::uint64(), *ctx->memory_pool(), length);
+                    *res = Dispatch2<true, false>(batch, length, state, builder);
                 }
-                if (TArgsPolicy::IsFixedArg[j]) {
-                    fixedArrays[j] = array.GetValues<ui64>(1);
+            }
+        } else {
+            if (hasNulls) {
+                if constexpr (IsFixedResult) {
+                    NUdf::TFixedSizeArrayBuilder<ui64, true> builder(NKikimr::NMiniKQL::TTypeInfoHelper(), arrow::uint64(), *ctx->memory_pool(), length);
+                    *res = Dispatch2<false, true>(batch, length, state, builder);
                 } else {
-                    stringOffsetsArrays[j] = array.GetValues<ui32>(1);
-                    stringDataArrays[j] = array.GetValues<ui8>(2);
+                    NUdf::TStringArrayBuilder<arrow::BinaryType, true> builder(NKikimr::NMiniKQL::TTypeInfoHelper(), arrow::uint64(), *ctx->memory_pool(), length);
+                    *res = Dispatch2<false, true>(batch, length, state, builder);
+                }
+            } else {
+                if constexpr (IsFixedResult) {
+                    NUdf::TFixedSizeArrayBuilder<ui64, true> builder(NKikimr::NMiniKQL::TTypeInfoHelper(), arrow::uint64(), *ctx->memory_pool(), length);
+                    *res = Dispatch2<false, false>(batch, length, state, builder);
+                } else {
+                    NUdf::TStringArrayBuilder<arrow::BinaryType, true> builder(NKikimr::NMiniKQL::TTypeInfoHelper(), arrow::uint64(), *ctx->memory_pool(), length);
+                    *res = Dispatch2<false, false>(batch, length, state, builder);
                 }
             }
         }
     }
 
-    ui64* fixedResultData = nullptr;
-    ui8* fixedResultValidMask = nullptr;
-    if constexpr (IsFixedResult) {
-        builder.UnsafeReserve(length);
-        fixedResultData = builder.MutableData();
-        fixedResultValidMask = builder.MutableValidMask();
+    template <bool HasScalars, bool HasNulls, typename TBuilder>
+    Y_NO_INLINE arrow::Datum Dispatch2(const arrow::compute::ExecBatch& batch, size_t length, const TPgKernelState& state, TBuilder& builder) const {
+        if constexpr (!TArgsPolicy::VarArgs) {
+            if (TArgsPolicy::IsFixedArg.size() == 2) {
+                if (batch.values[0].is_scalar()) {
+                    return Dispatch3<HasScalars, HasNulls, EScalarArgBinary::First>(batch, length, state, builder);                
+                }
+
+                if (batch.values[1].is_scalar()) {
+                    return Dispatch3<HasScalars, HasNulls, EScalarArgBinary::Second>(batch, length, state, builder);                
+                }
+            }
+        }
+
+        return Dispatch3<HasScalars, HasNulls, EScalarArgBinary::Unknown>(batch, length, state, builder);
     }
 
-    for (size_t i = 0; i < length; ++i) {
-        Datum ret;
+    template <bool HasScalars, bool HasNulls, EScalarArgBinary ScalarArgBinary, typename TBuilder>
+    Y_NO_INLINE arrow::Datum Dispatch3(const arrow::compute::ExecBatch& batch, size_t length, const TPgKernelState& state, TBuilder& builder) const {
+        LOCAL_FCINFO(fcinfo, FUNC_MAX_ARGS);    
+        fcinfo->flinfo = state.flinfo;
+        fcinfo->context = state.context;
+        fcinfo->resultinfo = state.resultinfo;
+        fcinfo->fncollation = state.fncollation;
+        fcinfo->nargs = batch.values.size();    
+
+        std::array<NullableDatum, TArgsPolicy::IsFixedArg.size()> scalars;
+        std::array<bool, TArgsPolicy::IsFixedArg.size()> isScalar;
+        std::array<ui64, TArgsPolicy::IsFixedArg.size()> offsets;
+        std::array<const ui8*, TArgsPolicy::IsFixedArg.size()> validMasks;
+        std::array<ui64, TArgsPolicy::IsFixedArg.size()> validOffsetMask;
+        ui8 fakeValidByte = 0xFF;
+        std::array<const ui64*, TArgsPolicy::IsFixedArg.size()> fixedArrays;
+        std::array<const ui32*, TArgsPolicy::IsFixedArg.size()> stringOffsetsArrays;
+        std::array<const ui8*, TArgsPolicy::IsFixedArg.size()> stringDataArrays;
         if constexpr (!TArgsPolicy::VarArgs) {
-            if (!constexpr_for_tuple([&](auto const& j, auto const& v) {
-                NullableDatum d;
-                if (HasScalars && (
-                    (ScalarArgBinary == EScalarArgBinary::First && j == 0) || 
-                    (ScalarArgBinary == EScalarArgBinary::Second && j == 1) || 
-                    isScalar[j])) {
-                    d = scalars[j];
+            for (size_t j = 0; j < TArgsPolicy::IsFixedArg.size(); ++j) {
+                isScalar[j] = batch.values[j].is_scalar();
+                if (isScalar[j]) {
+                    const auto& scalar = *batch.values[j].scalar();
+                    if (!scalar.is_valid) {
+                        scalars[j].isnull = true;
+                    } else {
+                        scalars[j].isnull = false;
+                        if (TArgsPolicy::IsFixedArg[j]) {
+                            scalars[j].value = (Datum)*static_cast<const ui64*>(arrow::internal::checked_cast<const arrow::internal::PrimitiveScalarBase&>(scalar).data());
+                        } else {
+                            auto buffer = arrow::internal::checked_cast<const arrow::BaseBinaryScalar&>(scalar).value;
+                            scalars[j].value = (Datum)buffer->data();
+                        }
+                    }
                 } else {
-                    d.isnull = false;                    
-                    if constexpr (HasNulls) {
-                        ui64 fullIndex = (i + offsets[j]) & validOffsetMask[j];
-                        d.isnull = ((validMasks[j][fullIndex >> 3] >> (fullIndex & 0x07)) & 1) == 0;
+                    const auto& array = *batch.values[j].array();
+                    offsets[j] = array.offset;
+                    validMasks[j] = array.GetValues<ui8>(0, 0);
+                    if (validMasks[j]) {
+                        validOffsetMask[j] = ~0ull;
+                    } else {
+                        validOffsetMask[j] = 0ull;
+                        validMasks[j] = &fakeValidByte;                    
                     }
-
-                    if (v) {
-                        d.value = (Datum)fixedArrays[j][i];
+                    if (TArgsPolicy::IsFixedArg[j]) {
+                        fixedArrays[j] = array.GetValues<ui64>(1);
                     } else {
-                        d.value = (Datum)(stringOffsetsArrays[j][i] + stringDataArrays[j]);
+                        stringOffsetsArrays[j] = array.GetValues<ui32>(1);
+                        stringDataArrays[j] = array.GetValues<ui8>(2);
                     }
                 }
+            }
+        }
 
-                if (HasNulls && IsStrict && d.isnull) {
-                    return false;
-                }
+        ui64* fixedResultData = nullptr;
+        ui8* fixedResultValidMask = nullptr;
+        if constexpr (IsFixedResult) {
+            builder.UnsafeReserve(length);
+            fixedResultData = builder.MutableData();
+            fixedResultValidMask = builder.MutableValidMask();
+        }
 
-                fcinfo->args[j] = d;
-                return true;            
-            }, TArgsPolicy::IsFixedArg)) {
-                if constexpr (IsFixedResult) {
-                    fixedResultValidMask[i] = 0;
-                } else {
-                    builder.Add(NUdf::TBlockItem{});
-                }
-                goto SkipCall;
-            }
-        } else {
-            for (size_t j = 0; j < batch.values.size(); ++j) {
-                NullableDatum d;
-                if (HasScalars && batch.values[j].is_scalar()) {
-                    if (state.IsFixedArg[j]) {
-                        FillScalarItem<HasNulls, true>(*batch.values[j].scalar(), d);
+        for (size_t i = 0; i < length; ++i) {
+            Datum ret;
+            if constexpr (!TArgsPolicy::VarArgs) {
+                if (!constexpr_for_tuple([&](auto const& j, auto const& v) {
+                    NullableDatum d;
+                    if (HasScalars && (
+                        (ScalarArgBinary == EScalarArgBinary::First && j == 0) || 
+                        (ScalarArgBinary == EScalarArgBinary::Second && j == 1) || 
+                        isScalar[j])) {
+                        d = scalars[j];
                     } else {
-                        FillScalarItem<HasNulls, false>(*batch.values[j].scalar(), d);
+                        d.isnull = false;                    
+                        if constexpr (HasNulls) {
+                            ui64 fullIndex = (i + offsets[j]) & validOffsetMask[j];
+                            d.isnull = ((validMasks[j][fullIndex >> 3] >> (fullIndex & 0x07)) & 1) == 0;
+                        }
+
+                        if (v) {
+                            d.value = (Datum)fixedArrays[j][i];
+                        } else {
+                            d.value = (Datum)(stringOffsetsArrays[j][i] + stringDataArrays[j]);
+                        }
                     }
-                } else {
-                    if (state.IsFixedArg[j]) {
-                        FillArrayItem<HasNulls, true>(*batch.values[j].array(), i, d);
-                    } else {
-                        FillArrayItem<HasNulls, false>(*batch.values[j].array(), i, d);
+
+                    if (HasNulls && IsStrict && d.isnull) {
+                        return false;
                     }
-                }
 
-                if (HasNulls && IsStrict && d.isnull) {
+                    fcinfo->args[j] = d;
+                    return true;            
+                }, TArgsPolicy::IsFixedArg)) {
                     if constexpr (IsFixedResult) {
                         fixedResultValidMask[i] = 0;
                     } else {
@@ -231,137 +329,71 @@ Y_NO_INLINE arrow::Datum GenericExecImpl(const arrow::compute::ExecBatch& batch,
                     }
                     goto SkipCall;
                 }
-
-                fcinfo->args[j] = d;            
-            }
-        }
-
-        fcinfo->isnull = false;
-        ret = TFunc()(fcinfo);
-        if constexpr (IsFixedResult) {
-            fixedResultData[i] = ui64(ret);
-            fixedResultValidMask[i] = !fcinfo->isnull;
-        } else {
-            if (fcinfo->isnull) {
-                builder.Add(NUdf::TBlockItem{});
             } else {
-                auto ptr = (const char*)ret;
-                auto len = state.IsCStringResult ? 1 + strlen(ptr) : VARHDRSZ + VARSIZE((const text*)ptr);
-                builder.Add(NUdf::TBlockItem(NUdf::TStringRef(ptr, len)));
-            }
-        }
-SkipCall:;
-    }
+                for (size_t j = 0; j < batch.values.size(); ++j) {
+                    NullableDatum d;
+                    if (HasScalars && batch.values[j].is_scalar()) {
+                        if (state.IsFixedArg[j]) {
+                            FillScalarItem<HasNulls, true>(*batch.values[j].scalar(), d);
+                        } else {
+                            FillScalarItem<HasNulls, false>(*batch.values[j].scalar(), d);
+                        }
+                    } else {
+                        if (state.IsFixedArg[j]) {
+                            FillArrayItem<HasNulls, true>(*batch.values[j].array(), i, d);
+                        } else {
+                            FillArrayItem<HasNulls, false>(*batch.values[j].array(), i, d);
+                        }
+                    }
 
-    return builder.Build(true);    
-}
+                    if (HasNulls && IsStrict && d.isnull) {
+                        if constexpr (IsFixedResult) {
+                            fixedResultValidMask[i] = 0;
+                        } else {
+                            builder.Add(NUdf::TBlockItem{});
+                        }
+                        goto SkipCall;
+                    }
 
-template <typename TFunc, bool IsStrict, bool IsFixedResult, bool HasScalars, bool HasNulls, typename TArgsPolicy, typename TBuilder>
-Y_NO_INLINE arrow::Datum GenericExecImpl3(const arrow::compute::ExecBatch& batch, size_t length, const TPgKernelState& state, TBuilder& builder) {
-    if constexpr (!TArgsPolicy::VarArgs) {
-        if (TArgsPolicy::IsFixedArg.size() == 2) {
-            if (batch.values[0].is_scalar()) {
-                return GenericExecImpl<TFunc, IsStrict, IsFixedResult, HasScalars, HasNulls, TArgsPolicy, EScalarArgBinary::First, TBuilder>(batch, length, state, builder);                
+                    fcinfo->args[j] = d;            
+                }
             }
 
-            if (batch.values[1].is_scalar()) {
-                return GenericExecImpl<TFunc, IsStrict, IsFixedResult, HasScalars, HasNulls, TArgsPolicy, EScalarArgBinary::Second, TBuilder>(batch, length, state, builder);                
-            }
-        }
-    }
-
-    return GenericExecImpl<TFunc, IsStrict, IsFixedResult, HasScalars, HasNulls, TArgsPolicy, EScalarArgBinary::Unknown, TBuilder>(batch, length, state, builder);
-}
-
-template <typename TFunc, bool IsStrict, bool IsFixedResult, typename TArgsPolicy>
-Y_NO_INLINE void GenericExecImpl2(bool hasScalars, bool hasNulls, arrow::compute::KernelContext* ctx,
-    const arrow::compute::ExecBatch& batch, size_t length, const TPgKernelState& state, arrow::Datum* res) {
-    if (hasScalars) {
-        if (hasNulls) {
-            if constexpr (IsFixedResult) {
-                NUdf::TFixedSizeArrayBuilder<ui64, true> builder(NKikimr::NMiniKQL::TTypeInfoHelper(), arrow::uint64(), *ctx->memory_pool(), length);
-                *res = GenericExecImpl3<TFunc, IsStrict, IsFixedResult, true, true, TArgsPolicy>(batch, length, state, builder);
-            } else {
-                NUdf::TStringArrayBuilder<arrow::BinaryType, true, NUdf::EPgStringType::None> builder(NKikimr::NMiniKQL::TTypeInfoHelper(), arrow::uint64(), *ctx->memory_pool(), length);
-                *res = GenericExecImpl3<TFunc, IsStrict, IsFixedResult, true, true, TArgsPolicy>(batch, length, state, builder);
-            }
-        } else {
-            if constexpr (IsFixedResult) {
-                NUdf::TFixedSizeArrayBuilder<ui64, true> builder(NKikimr::NMiniKQL::TTypeInfoHelper(), arrow::uint64(), *ctx->memory_pool(), length);
-                *res = GenericExecImpl3<TFunc, IsStrict, IsFixedResult, true, false, TArgsPolicy>(batch, length, state, builder);
-            } else {
-                NUdf::TStringArrayBuilder<arrow::BinaryType, true, NUdf::EPgStringType::None> builder(NKikimr::NMiniKQL::TTypeInfoHelper(), arrow::uint64(), *ctx->memory_pool(), length);
-                *res = GenericExecImpl3<TFunc, IsStrict, IsFixedResult, true, false, TArgsPolicy>(batch, length, state, builder);
-            }
-        }
-    } else {
-        if (hasNulls) {
+            fcinfo->isnull = false;
+            ret = Func(fcinfo);
             if constexpr (IsFixedResult) {
-                NUdf::TFixedSizeArrayBuilder<ui64, true> builder(NKikimr::NMiniKQL::TTypeInfoHelper(), arrow::uint64(), *ctx->memory_pool(), length);
-                *res = GenericExecImpl3<TFunc, IsStrict, IsFixedResult, false, true, TArgsPolicy>(batch, length, state, builder);
+                fixedResultData[i] = ui64(ret);
+                fixedResultValidMask[i] = !fcinfo->isnull;
             } else {
-                NUdf::TStringArrayBuilder<arrow::BinaryType, true> builder(NKikimr::NMiniKQL::TTypeInfoHelper(), arrow::uint64(), *ctx->memory_pool(), length);
-                *res = GenericExecImpl3<TFunc, IsStrict, IsFixedResult, false, true, TArgsPolicy>(batch, length, state, builder);
-            }
-        } else {
-            if constexpr (IsFixedResult) {
-                NUdf::TFixedSizeArrayBuilder<ui64, true> builder(NKikimr::NMiniKQL::TTypeInfoHelper(), arrow::uint64(), *ctx->memory_pool(), length);
-                *res = GenericExecImpl3<TFunc, IsStrict, IsFixedResult, false, false, TArgsPolicy>(batch, length, state, builder);
-            } else {
-                NUdf::TStringArrayBuilder<arrow::BinaryType, true> builder(NKikimr::NMiniKQL::TTypeInfoHelper(), arrow::uint64(), *ctx->memory_pool(), length);
-                *res = GenericExecImpl3<TFunc, IsStrict, IsFixedResult, false, false, TArgsPolicy>(batch, length, state, builder);
+                if (fcinfo->isnull) {
+                    builder.Add(NUdf::TBlockItem{});
+                } else {
+                    auto ptr = (const char*)ret;
+                    auto len = state.IsCStringResult ? 1 + strlen(ptr) : VARHDRSZ + VARSIZE((const text*)ptr);
+                    builder.Add(NUdf::TBlockItem(NUdf::TStringRef(ptr, len)));
+                }
             }
+    SkipCall:;
         }
-    }
-}
 
-struct TDefaultArgsPolicy {
-    static constexpr bool VarArgs = true;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
-};
-
-extern "C" TPgKernelState& GetPGKernelState(arrow::compute::KernelContext* ctx);
-
-template <typename TFunc, bool IsStrict, bool IsFixedResult, typename TArgsPolicy = TDefaultArgsPolicy>
-Y_NO_INLINE arrow::Status GenericExec(arrow::compute::KernelContext* ctx, const arrow::compute::ExecBatch& batch, arrow::Datum* res) {
-    const auto& state = GetPGKernelState(ctx);
-    if constexpr (!TArgsPolicy::VarArgs) {
-        Y_ENSURE(batch.values.size() == TArgsPolicy::IsFixedArg.size());
-        Y_ENSURE(state.IsFixedArg.size() == TArgsPolicy::IsFixedArg.size());
-        for (ui32 i = 0; i < TArgsPolicy::IsFixedArg.size(); ++i) {
-            Y_ENSURE(state.IsFixedArg[i] == TArgsPolicy::IsFixedArg[i]);
-        }
+        return builder.Build(true);    
     }
 
-    size_t length = 1;
-    bool hasNulls = false;
-    bool hasArrays = false;
-    bool hasScalars = false;
-    for (const auto& v : batch.values) {
-        if (v.is_array()) {
-            length = v.array()->length;
-            if (v.array()->GetNullCount() > 0) {
-                hasNulls = true;
-            }
+    TFunc Func;
+};
 
-            hasArrays = true;
-        } else {
-            hasScalars = true;
-            if (!v.scalar()->is_valid) {
-                hasNulls = true;
-            }
-        }
-    }
+using TExecFunc = std::function<arrow::Status(arrow::compute::KernelContext* ctx, const arrow::compute::ExecBatch& batch, arrow::Datum* res)>;
 
-    Y_ENSURE(hasArrays);
-    Y_ENSURE(state.flinfo->fn_strict == IsStrict);
-    Y_ENSURE(state.IsFixedResult == IsFixedResult);
-    TArenaMemoryContext arena;
-    GenericExecImpl2<TFunc, IsStrict, IsFixedResult, TArgsPolicy>(hasScalars, hasNulls, ctx, batch, length, state, res);
-    return arrow::Status::OK();
+template <bool IsStrict, bool IsFixedResult>
+TExecFunc MakeIndirectExec(PGFunction pgFunc) {
+    return TGenericExec<TPgIndirectFunc, IsStrict, IsFixedResult>(TPgIndirectFunc(pgFunc));
 }
 
-typedef arrow::Status (*TExecFunc)(arrow::compute::KernelContext* ctx, const arrow::compute::ExecBatch& batch, arrow::Datum* res);
+#if defined(_tsan_enabled_) || defined(_msan_enabled_) || defined(_asan_enabled_) || !defined(NDEBUG)
+#ifndef USE_SLOW_PG_KERNELS
+#define USE_SLOW_PG_KERNELS
+#endif
+#endif
 
 TExecFunc FindExec(Oid oid);
 void RegisterExec(Oid oid, TExecFunc func);
diff --git a/ydb/library/yql/parser/pg_wrapper/pg_kernels.0.cpp b/ydb/library/yql/parser/pg_wrapper/pg_kernels.0.cpp
index c092136c95d..e55a7dad488 100644
--- a/ydb/library/yql/parser/pg_wrapper/pg_kernels.0.cpp
+++ b/ydb/library/yql/parser/pg_wrapper/pg_kernels.0.cpp
@@ -28,7 +28,11 @@ namespace NYql {
 
 extern "C" {
 
+#ifdef USE_SLOW_PG_KERNELS
+#include "pg_kernels.slow.0.inc"
+#else
 #include "pg_kernels.0.inc"
+#endif
 
 }
 
diff --git a/ydb/library/yql/parser/pg_wrapper/pg_kernels.0.inc b/ydb/library/yql/parser/pg_wrapper/pg_kernels.0.inc
index 693eba803c0..9491a86aaf6 100644
--- a/ydb/library/yql/parser/pg_wrapper/pg_kernels.0.inc
+++ b/ydb/library/yql/parser/pg_wrapper/pg_kernels.0.inc
@@ -1,3040 +1,2427 @@
-struct TArgs_amvalidate_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_amvalidate() { return &GenericExec<TPgDirectFunc<&amvalidate>, true, true, TArgs_amvalidate_Policy>; }
-struct TArgs_any_in_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_any_in() { return &GenericExec<TPgDirectFunc<&any_in>, true, true, TArgs_any_in_Policy>; }
-struct TArgs_any_out_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_any_out() { return &GenericExec<TPgDirectFunc<&any_out>, true, false, TArgs_any_out_Policy>; }
-struct TArgs_anyarray_in_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_anyarray_in() { return &GenericExec<TPgDirectFunc<&anyarray_in>, true, false, TArgs_anyarray_in_Policy>; }
-struct TArgs_anyarray_out_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_anyarray_out() { return &GenericExec<TPgDirectFunc<&anyarray_out>, true, false, TArgs_anyarray_out_Policy>; }
-struct TArgs_anyarray_recv_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_anyarray_recv() { return &GenericExec<TPgDirectFunc<&anyarray_recv>, true, false, TArgs_anyarray_recv_Policy>; }
-struct TArgs_anyarray_send_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_anyarray_send() { return &GenericExec<TPgDirectFunc<&anyarray_send>, true, false, TArgs_anyarray_send_Policy>; }
-struct TArgs_anycompatible_in_Policy {
+struct TArgs_PG_char_to_encoding_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_anycompatible_in() { return &GenericExec<TPgDirectFunc<&anycompatible_in>, true, true, TArgs_anycompatible_in_Policy>; }
-struct TArgs_anycompatible_out_Policy {
+TExecFunc arrow_PG_char_to_encoding() { return TGenericExec<TPgDirectFunc<&PG_char_to_encoding>, true, true, TArgs_PG_char_to_encoding_Policy>({}); }
+struct TArgs_PG_encoding_to_char_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_anycompatible_out() { return &GenericExec<TPgDirectFunc<&anycompatible_out>, true, false, TArgs_anycompatible_out_Policy>; }
-struct TArgs_anycompatiblearray_in_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_anycompatiblearray_in() { return &GenericExec<TPgDirectFunc<&anycompatiblearray_in>, true, false, TArgs_anycompatiblearray_in_Policy>; }
-struct TArgs_anycompatiblearray_out_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_anycompatiblearray_out() { return &GenericExec<TPgDirectFunc<&anycompatiblearray_out>, true, false, TArgs_anycompatiblearray_out_Policy>; }
-struct TArgs_anycompatiblearray_recv_Policy {
+TExecFunc arrow_PG_encoding_to_char() { return TGenericExec<TPgDirectFunc<&PG_encoding_to_char>, true, false, TArgs_PG_encoding_to_char_Policy>({}); }
+struct TArgs_array_subscript_handler_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_anycompatiblearray_recv() { return &GenericExec<TPgDirectFunc<&anycompatiblearray_recv>, true, false, TArgs_anycompatiblearray_recv_Policy>; }
-struct TArgs_anycompatiblearray_send_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_anycompatiblearray_send() { return &GenericExec<TPgDirectFunc<&anycompatiblearray_send>, true, false, TArgs_anycompatiblearray_send_Policy>; }
-struct TArgs_anycompatiblemultirange_in_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
-};
-TExecFunc arrow_anycompatiblemultirange_in() { return &GenericExec<TPgDirectFunc<&anycompatiblemultirange_in>, true, false, TArgs_anycompatiblemultirange_in_Policy>; }
-struct TArgs_anycompatiblemultirange_out_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_anycompatiblemultirange_out() { return &GenericExec<TPgDirectFunc<&anycompatiblemultirange_out>, true, false, TArgs_anycompatiblemultirange_out_Policy>; }
-struct TArgs_anycompatiblenonarray_in_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_anycompatiblenonarray_in() { return &GenericExec<TPgDirectFunc<&anycompatiblenonarray_in>, true, true, TArgs_anycompatiblenonarray_in_Policy>; }
-struct TArgs_anycompatiblenonarray_out_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_anycompatiblenonarray_out() { return &GenericExec<TPgDirectFunc<&anycompatiblenonarray_out>, true, false, TArgs_anycompatiblenonarray_out_Policy>; }
-struct TArgs_anycompatiblerange_in_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
-};
-TExecFunc arrow_anycompatiblerange_in() { return &GenericExec<TPgDirectFunc<&anycompatiblerange_in>, true, false, TArgs_anycompatiblerange_in_Policy>; }
-struct TArgs_anycompatiblerange_out_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_anycompatiblerange_out() { return &GenericExec<TPgDirectFunc<&anycompatiblerange_out>, true, false, TArgs_anycompatiblerange_out_Policy>; }
-struct TArgs_anyelement_in_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_anyelement_in() { return &GenericExec<TPgDirectFunc<&anyelement_in>, true, true, TArgs_anyelement_in_Policy>; }
-struct TArgs_anyelement_out_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_anyelement_out() { return &GenericExec<TPgDirectFunc<&anyelement_out>, true, false, TArgs_anyelement_out_Policy>; }
-struct TArgs_anyenum_in_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_anyenum_in() { return &GenericExec<TPgDirectFunc<&anyenum_in>, true, true, TArgs_anyenum_in_Policy>; }
-struct TArgs_anyenum_out_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_anyenum_out() { return &GenericExec<TPgDirectFunc<&anyenum_out>, true, false, TArgs_anyenum_out_Policy>; }
-struct TArgs_anymultirange_in_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
-};
-TExecFunc arrow_anymultirange_in() { return &GenericExec<TPgDirectFunc<&anymultirange_in>, true, false, TArgs_anymultirange_in_Policy>; }
-struct TArgs_anymultirange_out_Policy {
+TExecFunc arrow_array_subscript_handler() { return TGenericExec<TPgDirectFunc<&array_subscript_handler>, true, true, TArgs_array_subscript_handler_Policy>({}); }
+struct TArgs_array_to_json_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_anymultirange_out() { return &GenericExec<TPgDirectFunc<&anymultirange_out>, true, false, TArgs_anymultirange_out_Policy>; }
-struct TArgs_anynonarray_in_Policy {
+TExecFunc arrow_array_to_json() { return TGenericExec<TPgDirectFunc<&array_to_json>, true, false, TArgs_array_to_json_Policy>({}); }
+struct TArgs_array_to_json_pretty_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_anynonarray_in() { return &GenericExec<TPgDirectFunc<&anynonarray_in>, true, true, TArgs_anynonarray_in_Policy>; }
-struct TArgs_anynonarray_out_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_anynonarray_out() { return &GenericExec<TPgDirectFunc<&anynonarray_out>, true, false, TArgs_anynonarray_out_Policy>; }
-struct TArgs_anyrange_in_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_anyrange_in() { return &GenericExec<TPgDirectFunc<&anyrange_in>, true, false, TArgs_anyrange_in_Policy>; }
-struct TArgs_anyrange_out_Policy {
+TExecFunc arrow_array_to_json_pretty() { return TGenericExec<TPgDirectFunc<&array_to_json_pretty>, true, false, TArgs_array_to_json_pretty_Policy>({}); }
+struct TArgs_ascii_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_anyrange_out() { return &GenericExec<TPgDirectFunc<&anyrange_out>, true, false, TArgs_anyrange_out_Policy>; }
+TExecFunc arrow_ascii() { return TGenericExec<TPgDirectFunc<&ascii>, true, true, TArgs_ascii_Policy>({}); }
 struct TArgs_be_lo_close_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_be_lo_close() { return &GenericExec<TPgDirectFunc<&be_lo_close>, true, true, TArgs_be_lo_close_Policy>; }
+TExecFunc arrow_be_lo_close() { return TGenericExec<TPgDirectFunc<&be_lo_close>, true, true, TArgs_be_lo_close_Policy>({}); }
 struct TArgs_be_lo_creat_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_be_lo_creat() { return &GenericExec<TPgDirectFunc<&be_lo_creat>, true, true, TArgs_be_lo_creat_Policy>; }
+TExecFunc arrow_be_lo_creat() { return TGenericExec<TPgDirectFunc<&be_lo_creat>, true, true, TArgs_be_lo_creat_Policy>({}); }
 struct TArgs_be_lo_create_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_be_lo_create() { return &GenericExec<TPgDirectFunc<&be_lo_create>, true, true, TArgs_be_lo_create_Policy>; }
+TExecFunc arrow_be_lo_create() { return TGenericExec<TPgDirectFunc<&be_lo_create>, true, true, TArgs_be_lo_create_Policy>({}); }
 struct TArgs_be_lo_export_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_be_lo_export() { return &GenericExec<TPgDirectFunc<&be_lo_export>, true, true, TArgs_be_lo_export_Policy>; }
+TExecFunc arrow_be_lo_export() { return TGenericExec<TPgDirectFunc<&be_lo_export>, true, true, TArgs_be_lo_export_Policy>({}); }
 struct TArgs_be_lo_from_bytea_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_be_lo_from_bytea() { return &GenericExec<TPgDirectFunc<&be_lo_from_bytea>, true, true, TArgs_be_lo_from_bytea_Policy>; }
+TExecFunc arrow_be_lo_from_bytea() { return TGenericExec<TPgDirectFunc<&be_lo_from_bytea>, true, true, TArgs_be_lo_from_bytea_Policy>({}); }
 struct TArgs_be_lo_get_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_be_lo_get() { return &GenericExec<TPgDirectFunc<&be_lo_get>, true, false, TArgs_be_lo_get_Policy>; }
+TExecFunc arrow_be_lo_get() { return TGenericExec<TPgDirectFunc<&be_lo_get>, true, false, TArgs_be_lo_get_Policy>({}); }
 struct TArgs_be_lo_get_fragment_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_be_lo_get_fragment() { return &GenericExec<TPgDirectFunc<&be_lo_get_fragment>, true, false, TArgs_be_lo_get_fragment_Policy>; }
+TExecFunc arrow_be_lo_get_fragment() { return TGenericExec<TPgDirectFunc<&be_lo_get_fragment>, true, false, TArgs_be_lo_get_fragment_Policy>({}); }
 struct TArgs_be_lo_import_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_be_lo_import() { return &GenericExec<TPgDirectFunc<&be_lo_import>, true, true, TArgs_be_lo_import_Policy>; }
+TExecFunc arrow_be_lo_import() { return TGenericExec<TPgDirectFunc<&be_lo_import>, true, true, TArgs_be_lo_import_Policy>({}); }
 struct TArgs_be_lo_import_with_oid_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_be_lo_import_with_oid() { return &GenericExec<TPgDirectFunc<&be_lo_import_with_oid>, true, true, TArgs_be_lo_import_with_oid_Policy>; }
+TExecFunc arrow_be_lo_import_with_oid() { return TGenericExec<TPgDirectFunc<&be_lo_import_with_oid>, true, true, TArgs_be_lo_import_with_oid_Policy>({}); }
 struct TArgs_be_lo_lseek_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_be_lo_lseek() { return &GenericExec<TPgDirectFunc<&be_lo_lseek>, true, true, TArgs_be_lo_lseek_Policy>; }
+TExecFunc arrow_be_lo_lseek() { return TGenericExec<TPgDirectFunc<&be_lo_lseek>, true, true, TArgs_be_lo_lseek_Policy>({}); }
 struct TArgs_be_lo_lseek64_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_be_lo_lseek64() { return &GenericExec<TPgDirectFunc<&be_lo_lseek64>, true, true, TArgs_be_lo_lseek64_Policy>; }
+TExecFunc arrow_be_lo_lseek64() { return TGenericExec<TPgDirectFunc<&be_lo_lseek64>, true, true, TArgs_be_lo_lseek64_Policy>({}); }
 struct TArgs_be_lo_open_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_be_lo_open() { return &GenericExec<TPgDirectFunc<&be_lo_open>, true, true, TArgs_be_lo_open_Policy>; }
+TExecFunc arrow_be_lo_open() { return TGenericExec<TPgDirectFunc<&be_lo_open>, true, true, TArgs_be_lo_open_Policy>({}); }
 struct TArgs_be_lo_put_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
 };
-TExecFunc arrow_be_lo_put() { return &GenericExec<TPgDirectFunc<&be_lo_put>, true, true, TArgs_be_lo_put_Policy>; }
+TExecFunc arrow_be_lo_put() { return TGenericExec<TPgDirectFunc<&be_lo_put>, true, true, TArgs_be_lo_put_Policy>({}); }
 struct TArgs_be_lo_tell_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_be_lo_tell() { return &GenericExec<TPgDirectFunc<&be_lo_tell>, true, true, TArgs_be_lo_tell_Policy>; }
+TExecFunc arrow_be_lo_tell() { return TGenericExec<TPgDirectFunc<&be_lo_tell>, true, true, TArgs_be_lo_tell_Policy>({}); }
 struct TArgs_be_lo_tell64_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_be_lo_tell64() { return &GenericExec<TPgDirectFunc<&be_lo_tell64>, true, true, TArgs_be_lo_tell64_Policy>; }
+TExecFunc arrow_be_lo_tell64() { return TGenericExec<TPgDirectFunc<&be_lo_tell64>, true, true, TArgs_be_lo_tell64_Policy>({}); }
 struct TArgs_be_lo_truncate_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_be_lo_truncate() { return &GenericExec<TPgDirectFunc<&be_lo_truncate>, true, true, TArgs_be_lo_truncate_Policy>; }
+TExecFunc arrow_be_lo_truncate() { return TGenericExec<TPgDirectFunc<&be_lo_truncate>, true, true, TArgs_be_lo_truncate_Policy>({}); }
 struct TArgs_be_lo_truncate64_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_be_lo_truncate64() { return &GenericExec<TPgDirectFunc<&be_lo_truncate64>, true, true, TArgs_be_lo_truncate64_Policy>; }
+TExecFunc arrow_be_lo_truncate64() { return TGenericExec<TPgDirectFunc<&be_lo_truncate64>, true, true, TArgs_be_lo_truncate64_Policy>({}); }
 struct TArgs_be_lo_unlink_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_be_lo_unlink() { return &GenericExec<TPgDirectFunc<&be_lo_unlink>, true, true, TArgs_be_lo_unlink_Policy>; }
+TExecFunc arrow_be_lo_unlink() { return TGenericExec<TPgDirectFunc<&be_lo_unlink>, true, true, TArgs_be_lo_unlink_Policy>({}); }
 struct TArgs_be_loread_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_be_loread() { return &GenericExec<TPgDirectFunc<&be_loread>, true, false, TArgs_be_loread_Policy>; }
+TExecFunc arrow_be_loread() { return TGenericExec<TPgDirectFunc<&be_loread>, true, false, TArgs_be_loread_Policy>({}); }
 struct TArgs_be_lowrite_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_be_lowrite() { return &GenericExec<TPgDirectFunc<&be_lowrite>, true, true, TArgs_be_lowrite_Policy>; }
-struct TArgs_bit_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
-};
-TExecFunc arrow_bit() { return &GenericExec<TPgDirectFunc<&bit>, true, false, TArgs_bit_Policy>; }
-struct TArgs_bit_and_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_bit_and() { return &GenericExec<TPgDirectFunc<&bit_and>, true, false, TArgs_bit_and_Policy>; }
-struct TArgs_bit_bit_count_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_bit_bit_count() { return &GenericExec<TPgDirectFunc<&bit_bit_count>, true, true, TArgs_bit_bit_count_Policy>; }
-struct TArgs_bit_in_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
-};
-TExecFunc arrow_bit_in() { return &GenericExec<TPgDirectFunc<&bit_in>, true, false, TArgs_bit_in_Policy>; }
-struct TArgs_bit_or_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_bit_or() { return &GenericExec<TPgDirectFunc<&bit_or>, true, false, TArgs_bit_or_Policy>; }
-struct TArgs_bit_out_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_bit_out() { return &GenericExec<TPgDirectFunc<&bit_out>, true, false, TArgs_bit_out_Policy>; }
-struct TArgs_bit_recv_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
-};
-TExecFunc arrow_bit_recv() { return &GenericExec<TPgDirectFunc<&bit_recv>, true, false, TArgs_bit_recv_Policy>; }
-struct TArgs_bit_send_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_bit_send() { return &GenericExec<TPgDirectFunc<&bit_send>, true, false, TArgs_bit_send_Policy>; }
-struct TArgs_bitcat_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_bitcat() { return &GenericExec<TPgDirectFunc<&bitcat>, true, false, TArgs_bitcat_Policy>; }
-struct TArgs_bitcmp_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_bitcmp() { return &GenericExec<TPgDirectFunc<&bitcmp>, true, true, TArgs_bitcmp_Policy>; }
-struct TArgs_biteq_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_biteq() { return &GenericExec<TPgDirectFunc<&biteq>, true, true, TArgs_biteq_Policy>; }
-struct TArgs_bitfromint4_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
-};
-TExecFunc arrow_bitfromint4() { return &GenericExec<TPgDirectFunc<&bitfromint4>, true, false, TArgs_bitfromint4_Policy>; }
-struct TArgs_bitfromint8_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
-};
-TExecFunc arrow_bitfromint8() { return &GenericExec<TPgDirectFunc<&bitfromint8>, true, false, TArgs_bitfromint8_Policy>; }
-struct TArgs_bitge_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_bitge() { return &GenericExec<TPgDirectFunc<&bitge>, true, true, TArgs_bitge_Policy>; }
-struct TArgs_bitgetbit_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
-};
-TExecFunc arrow_bitgetbit() { return &GenericExec<TPgDirectFunc<&bitgetbit>, true, true, TArgs_bitgetbit_Policy>; }
-struct TArgs_bitgt_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_bitgt() { return &GenericExec<TPgDirectFunc<&bitgt>, true, true, TArgs_bitgt_Policy>; }
-struct TArgs_bitle_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_bitle() { return &GenericExec<TPgDirectFunc<&bitle>, true, true, TArgs_bitle_Policy>; }
-struct TArgs_bitlength_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_bitlength() { return &GenericExec<TPgDirectFunc<&bitlength>, true, true, TArgs_bitlength_Policy>; }
-struct TArgs_bitlt_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_bitlt() { return &GenericExec<TPgDirectFunc<&bitlt>, true, true, TArgs_bitlt_Policy>; }
-struct TArgs_bitne_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_bitne() { return &GenericExec<TPgDirectFunc<&bitne>, true, true, TArgs_bitne_Policy>; }
-struct TArgs_bitnot_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_bitnot() { return &GenericExec<TPgDirectFunc<&bitnot>, true, false, TArgs_bitnot_Policy>; }
-struct TArgs_bitoctetlength_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_bitoctetlength() { return &GenericExec<TPgDirectFunc<&bitoctetlength>, true, true, TArgs_bitoctetlength_Policy>; }
-struct TArgs_bitoverlay_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,false,true,true};
-};
-TExecFunc arrow_bitoverlay() { return &GenericExec<TPgDirectFunc<&bitoverlay>, true, false, TArgs_bitoverlay_Policy>; }
-struct TArgs_bitoverlay_no_len_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,true};
-};
-TExecFunc arrow_bitoverlay_no_len() { return &GenericExec<TPgDirectFunc<&bitoverlay_no_len>, true, false, TArgs_bitoverlay_no_len_Policy>; }
-struct TArgs_bitposition_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_bitposition() { return &GenericExec<TPgDirectFunc<&bitposition>, true, true, TArgs_bitposition_Policy>; }
-struct TArgs_bitsetbit_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
-};
-TExecFunc arrow_bitsetbit() { return &GenericExec<TPgDirectFunc<&bitsetbit>, true, false, TArgs_bitsetbit_Policy>; }
-struct TArgs_bitshiftleft_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
-};
-TExecFunc arrow_bitshiftleft() { return &GenericExec<TPgDirectFunc<&bitshiftleft>, true, false, TArgs_bitshiftleft_Policy>; }
-struct TArgs_bitshiftright_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
-};
-TExecFunc arrow_bitshiftright() { return &GenericExec<TPgDirectFunc<&bitshiftright>, true, false, TArgs_bitshiftright_Policy>; }
-struct TArgs_bitsubstr_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
-};
-TExecFunc arrow_bitsubstr() { return &GenericExec<TPgDirectFunc<&bitsubstr>, true, false, TArgs_bitsubstr_Policy>; }
-struct TArgs_bitsubstr_no_len_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
-};
-TExecFunc arrow_bitsubstr_no_len() { return &GenericExec<TPgDirectFunc<&bitsubstr_no_len>, true, false, TArgs_bitsubstr_no_len_Policy>; }
-struct TArgs_bittoint4_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_bittoint4() { return &GenericExec<TPgDirectFunc<&bittoint4>, true, true, TArgs_bittoint4_Policy>; }
-struct TArgs_bittoint8_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_bittoint8() { return &GenericExec<TPgDirectFunc<&bittoint8>, true, true, TArgs_bittoint8_Policy>; }
-struct TArgs_bittypmodin_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_bittypmodin() { return &GenericExec<TPgDirectFunc<&bittypmodin>, true, true, TArgs_bittypmodin_Policy>; }
-struct TArgs_bittypmodout_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_bittypmodout() { return &GenericExec<TPgDirectFunc<&bittypmodout>, true, false, TArgs_bittypmodout_Policy>; }
-struct TArgs_bitxor_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_bitxor() { return &GenericExec<TPgDirectFunc<&bitxor>, true, false, TArgs_bitxor_Policy>; }
+TExecFunc arrow_be_lowrite() { return TGenericExec<TPgDirectFunc<&be_lowrite>, true, true, TArgs_be_lowrite_Policy>({}); }
 struct TArgs_bool_accum_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_bool_accum() { return &GenericExec<TPgDirectFunc<&bool_accum>, false, true, TArgs_bool_accum_Policy>; }
+TExecFunc arrow_bool_accum() { return TGenericExec<TPgDirectFunc<&bool_accum>, false, true, TArgs_bool_accum_Policy>({}); }
 struct TArgs_bool_accum_inv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_bool_accum_inv() { return &GenericExec<TPgDirectFunc<&bool_accum_inv>, false, true, TArgs_bool_accum_inv_Policy>; }
+TExecFunc arrow_bool_accum_inv() { return TGenericExec<TPgDirectFunc<&bool_accum_inv>, false, true, TArgs_bool_accum_inv_Policy>({}); }
 struct TArgs_bool_alltrue_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_bool_alltrue() { return &GenericExec<TPgDirectFunc<&bool_alltrue>, true, true, TArgs_bool_alltrue_Policy>; }
+TExecFunc arrow_bool_alltrue() { return TGenericExec<TPgDirectFunc<&bool_alltrue>, true, true, TArgs_bool_alltrue_Policy>({}); }
 struct TArgs_bool_anytrue_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_bool_anytrue() { return &GenericExec<TPgDirectFunc<&bool_anytrue>, true, true, TArgs_bool_anytrue_Policy>; }
-struct TArgs_bool_int4_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_bool_int4() { return &GenericExec<TPgDirectFunc<&bool_int4>, true, true, TArgs_bool_int4_Policy>; }
+TExecFunc arrow_bool_anytrue() { return TGenericExec<TPgDirectFunc<&bool_anytrue>, true, true, TArgs_bool_anytrue_Policy>({}); }
 struct TArgs_booland_statefunc_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_booland_statefunc() { return &GenericExec<TPgDirectFunc<&booland_statefunc>, true, true, TArgs_booland_statefunc_Policy>; }
+TExecFunc arrow_booland_statefunc() { return TGenericExec<TPgDirectFunc<&booland_statefunc>, true, true, TArgs_booland_statefunc_Policy>({}); }
 struct TArgs_booleq_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_booleq() { return &GenericExec<TPgDirectFunc<&booleq>, true, true, TArgs_booleq_Policy>; }
+TExecFunc arrow_booleq() { return TGenericExec<TPgDirectFunc<&booleq>, true, true, TArgs_booleq_Policy>({}); }
 struct TArgs_boolge_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_boolge() { return &GenericExec<TPgDirectFunc<&boolge>, true, true, TArgs_boolge_Policy>; }
+TExecFunc arrow_boolge() { return TGenericExec<TPgDirectFunc<&boolge>, true, true, TArgs_boolge_Policy>({}); }
 struct TArgs_boolgt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_boolgt() { return &GenericExec<TPgDirectFunc<&boolgt>, true, true, TArgs_boolgt_Policy>; }
+TExecFunc arrow_boolgt() { return TGenericExec<TPgDirectFunc<&boolgt>, true, true, TArgs_boolgt_Policy>({}); }
 struct TArgs_boolin_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_boolin() { return &GenericExec<TPgDirectFunc<&boolin>, true, true, TArgs_boolin_Policy>; }
+TExecFunc arrow_boolin() { return TGenericExec<TPgDirectFunc<&boolin>, true, true, TArgs_boolin_Policy>({}); }
 struct TArgs_boolle_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_boolle() { return &GenericExec<TPgDirectFunc<&boolle>, true, true, TArgs_boolle_Policy>; }
+TExecFunc arrow_boolle() { return TGenericExec<TPgDirectFunc<&boolle>, true, true, TArgs_boolle_Policy>({}); }
 struct TArgs_boollt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_boollt() { return &GenericExec<TPgDirectFunc<&boollt>, true, true, TArgs_boollt_Policy>; }
+TExecFunc arrow_boollt() { return TGenericExec<TPgDirectFunc<&boollt>, true, true, TArgs_boollt_Policy>({}); }
 struct TArgs_boolne_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_boolne() { return &GenericExec<TPgDirectFunc<&boolne>, true, true, TArgs_boolne_Policy>; }
+TExecFunc arrow_boolne() { return TGenericExec<TPgDirectFunc<&boolne>, true, true, TArgs_boolne_Policy>({}); }
 struct TArgs_boolor_statefunc_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_boolor_statefunc() { return &GenericExec<TPgDirectFunc<&boolor_statefunc>, true, true, TArgs_boolor_statefunc_Policy>; }
+TExecFunc arrow_boolor_statefunc() { return TGenericExec<TPgDirectFunc<&boolor_statefunc>, true, true, TArgs_boolor_statefunc_Policy>({}); }
 struct TArgs_boolout_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_boolout() { return &GenericExec<TPgDirectFunc<&boolout>, true, false, TArgs_boolout_Policy>; }
+TExecFunc arrow_boolout() { return TGenericExec<TPgDirectFunc<&boolout>, true, false, TArgs_boolout_Policy>({}); }
 struct TArgs_boolrecv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_boolrecv() { return &GenericExec<TPgDirectFunc<&boolrecv>, true, true, TArgs_boolrecv_Policy>; }
+TExecFunc arrow_boolrecv() { return TGenericExec<TPgDirectFunc<&boolrecv>, true, true, TArgs_boolrecv_Policy>({}); }
 struct TArgs_boolsend_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_boolsend() { return &GenericExec<TPgDirectFunc<&boolsend>, true, false, TArgs_boolsend_Policy>; }
+TExecFunc arrow_boolsend() { return TGenericExec<TPgDirectFunc<&boolsend>, true, false, TArgs_boolsend_Policy>({}); }
 struct TArgs_booltext_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_booltext() { return &GenericExec<TPgDirectFunc<&booltext>, true, false, TArgs_booltext_Policy>; }
-struct TArgs_clock_timestamp_Policy {
+TExecFunc arrow_booltext() { return TGenericExec<TPgDirectFunc<&booltext>, true, false, TArgs_booltext_Policy>({}); }
+struct TArgs_brin_desummarize_range_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
-};
-TExecFunc arrow_clock_timestamp() { return &GenericExec<TPgDirectFunc<&clock_timestamp>, true, true, TArgs_clock_timestamp_Policy>; }
-struct TArgs_cstring_in_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_cstring_in() { return &GenericExec<TPgDirectFunc<&cstring_in>, true, false, TArgs_cstring_in_Policy>; }
-struct TArgs_cstring_out_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_cstring_out() { return &GenericExec<TPgDirectFunc<&cstring_out>, true, false, TArgs_cstring_out_Policy>; }
-struct TArgs_cstring_recv_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_cstring_recv() { return &GenericExec<TPgDirectFunc<&cstring_recv>, true, false, TArgs_cstring_recv_Policy>; }
-struct TArgs_cstring_send_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_cstring_send() { return &GenericExec<TPgDirectFunc<&cstring_send>, true, false, TArgs_cstring_send_Policy>; }
-struct TArgs_dsimple_init_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_dsimple_init() { return &GenericExec<TPgDirectFunc<&dsimple_init>, true, true, TArgs_dsimple_init_Policy>; }
-struct TArgs_dsimple_lexize_Policy {
+TExecFunc arrow_brin_desummarize_range() { return TGenericExec<TPgDirectFunc<&brin_desummarize_range>, true, true, TArgs_brin_desummarize_range_Policy>({}); }
+struct TArgs_brin_minmax_multi_add_value_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_dsimple_lexize() { return &GenericExec<TPgDirectFunc<&dsimple_lexize>, true, true, TArgs_dsimple_lexize_Policy>; }
-struct TArgs_event_trigger_in_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_event_trigger_in() { return &GenericExec<TPgDirectFunc<&event_trigger_in>, false, true, TArgs_event_trigger_in_Policy>; }
-struct TArgs_event_trigger_out_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_event_trigger_out() { return &GenericExec<TPgDirectFunc<&event_trigger_out>, true, false, TArgs_event_trigger_out_Policy>; }
-struct TArgs_extract_interval_Policy {
+TExecFunc arrow_brin_minmax_multi_add_value() { return TGenericExec<TPgDirectFunc<&brin_minmax_multi_add_value>, true, true, TArgs_brin_minmax_multi_add_value_Policy>({}); }
+struct TArgs_brin_minmax_multi_consistent_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_extract_interval() { return &GenericExec<TPgDirectFunc<&extract_interval>, true, false, TArgs_extract_interval_Policy>; }
-struct TArgs_extract_timestamp_Policy {
+TExecFunc arrow_brin_minmax_multi_consistent() { return TGenericExec<TPgDirectFunc<&brin_minmax_multi_consistent>, true, true, TArgs_brin_minmax_multi_consistent_Policy>({}); }
+struct TArgs_brin_minmax_multi_distance_date_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_extract_timestamp() { return &GenericExec<TPgDirectFunc<&extract_timestamp>, true, false, TArgs_extract_timestamp_Policy>; }
-struct TArgs_extract_timestamptz_Policy {
+TExecFunc arrow_brin_minmax_multi_distance_date() { return TGenericExec<TPgDirectFunc<&brin_minmax_multi_distance_date>, true, true, TArgs_brin_minmax_multi_distance_date_Policy>({}); }
+struct TArgs_brin_minmax_multi_distance_float4_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_extract_timestamptz() { return &GenericExec<TPgDirectFunc<&extract_timestamptz>, true, false, TArgs_extract_timestamptz_Policy>; }
-struct TArgs_fdw_handler_in_Policy {
+TExecFunc arrow_brin_minmax_multi_distance_float4() { return TGenericExec<TPgDirectFunc<&brin_minmax_multi_distance_float4>, true, true, TArgs_brin_minmax_multi_distance_float4_Policy>({}); }
+struct TArgs_brin_minmax_multi_distance_float8_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_fdw_handler_in() { return &GenericExec<TPgDirectFunc<&fdw_handler_in>, false, true, TArgs_fdw_handler_in_Policy>; }
-struct TArgs_fdw_handler_out_Policy {
+TExecFunc arrow_brin_minmax_multi_distance_float8() { return TGenericExec<TPgDirectFunc<&brin_minmax_multi_distance_float8>, true, true, TArgs_brin_minmax_multi_distance_float8_Policy>({}); }
+struct TArgs_brin_minmax_multi_distance_inet_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_fdw_handler_out() { return &GenericExec<TPgDirectFunc<&fdw_handler_out>, true, false, TArgs_fdw_handler_out_Policy>; }
-struct TArgs_float4_numeric_Policy {
+TExecFunc arrow_brin_minmax_multi_distance_inet() { return TGenericExec<TPgDirectFunc<&brin_minmax_multi_distance_inet>, true, true, TArgs_brin_minmax_multi_distance_inet_Policy>({}); }
+struct TArgs_brin_minmax_multi_distance_int2_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_float4_numeric() { return &GenericExec<TPgDirectFunc<&float4_numeric>, true, false, TArgs_float4_numeric_Policy>; }
-struct TArgs_float8_numeric_Policy {
+TExecFunc arrow_brin_minmax_multi_distance_int2() { return TGenericExec<TPgDirectFunc<&brin_minmax_multi_distance_int2>, true, true, TArgs_brin_minmax_multi_distance_int2_Policy>({}); }
+struct TArgs_brin_minmax_multi_distance_int4_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_float8_numeric() { return &GenericExec<TPgDirectFunc<&float8_numeric>, true, false, TArgs_float8_numeric_Policy>; }
-struct TArgs_float8_timestamptz_Policy {
+TExecFunc arrow_brin_minmax_multi_distance_int4() { return TGenericExec<TPgDirectFunc<&brin_minmax_multi_distance_int4>, true, true, TArgs_brin_minmax_multi_distance_int4_Policy>({}); }
+struct TArgs_brin_minmax_multi_distance_int8_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_float8_timestamptz() { return &GenericExec<TPgDirectFunc<&float8_timestamptz>, true, true, TArgs_float8_timestamptz_Policy>; }
-struct TArgs_generate_series_int4_support_Policy {
+TExecFunc arrow_brin_minmax_multi_distance_int8() { return TGenericExec<TPgDirectFunc<&brin_minmax_multi_distance_int8>, true, true, TArgs_brin_minmax_multi_distance_int8_Policy>({}); }
+struct TArgs_brin_minmax_multi_distance_interval_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_generate_series_int4_support() { return &GenericExec<TPgDirectFunc<&generate_series_int4_support>, true, true, TArgs_generate_series_int4_support_Policy>; }
-struct TArgs_get_current_ts_config_Policy {
+TExecFunc arrow_brin_minmax_multi_distance_interval() { return TGenericExec<TPgDirectFunc<&brin_minmax_multi_distance_interval>, true, true, TArgs_brin_minmax_multi_distance_interval_Policy>({}); }
+struct TArgs_brin_minmax_multi_distance_macaddr_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_get_current_ts_config() { return &GenericExec<TPgDirectFunc<&get_current_ts_config>, true, true, TArgs_get_current_ts_config_Policy>; }
-struct TArgs_gtsvector_compress_Policy {
+TExecFunc arrow_brin_minmax_multi_distance_macaddr() { return TGenericExec<TPgDirectFunc<&brin_minmax_multi_distance_macaddr>, true, true, TArgs_brin_minmax_multi_distance_macaddr_Policy>({}); }
+struct TArgs_brin_minmax_multi_distance_macaddr8_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_gtsvector_compress() { return &GenericExec<TPgDirectFunc<&gtsvector_compress>, true, true, TArgs_gtsvector_compress_Policy>; }
-struct TArgs_gtsvector_consistent_Policy {
+TExecFunc arrow_brin_minmax_multi_distance_macaddr8() { return TGenericExec<TPgDirectFunc<&brin_minmax_multi_distance_macaddr8>, true, true, TArgs_brin_minmax_multi_distance_macaddr8_Policy>({}); }
+struct TArgs_brin_minmax_multi_distance_numeric_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,false,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_gtsvector_consistent() { return &GenericExec<TPgDirectFunc<&gtsvector_consistent>, true, true, TArgs_gtsvector_consistent_Policy>; }
-struct TArgs_gtsvector_consistent_oldsig_Policy {
+TExecFunc arrow_brin_minmax_multi_distance_numeric() { return TGenericExec<TPgDirectFunc<&brin_minmax_multi_distance_numeric>, true, true, TArgs_brin_minmax_multi_distance_numeric_Policy>({}); }
+struct TArgs_brin_minmax_multi_distance_pg_lsn_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,false,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_gtsvector_consistent_oldsig() { return &GenericExec<TPgDirectFunc<&gtsvector_consistent_oldsig>, true, true, TArgs_gtsvector_consistent_oldsig_Policy>; }
-struct TArgs_gtsvector_decompress_Policy {
+TExecFunc arrow_brin_minmax_multi_distance_pg_lsn() { return TGenericExec<TPgDirectFunc<&brin_minmax_multi_distance_pg_lsn>, true, true, TArgs_brin_minmax_multi_distance_pg_lsn_Policy>({}); }
+struct TArgs_brin_minmax_multi_distance_tid_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_gtsvector_decompress() { return &GenericExec<TPgDirectFunc<&gtsvector_decompress>, true, true, TArgs_gtsvector_decompress_Policy>; }
-struct TArgs_gtsvector_options_Policy {
+TExecFunc arrow_brin_minmax_multi_distance_tid() { return TGenericExec<TPgDirectFunc<&brin_minmax_multi_distance_tid>, true, true, TArgs_brin_minmax_multi_distance_tid_Policy>({}); }
+struct TArgs_brin_minmax_multi_distance_time_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_gtsvector_options() { return &GenericExec<TPgDirectFunc<&gtsvector_options>, false, true, TArgs_gtsvector_options_Policy>; }
-struct TArgs_gtsvector_penalty_Policy {
+TExecFunc arrow_brin_minmax_multi_distance_time() { return TGenericExec<TPgDirectFunc<&brin_minmax_multi_distance_time>, true, true, TArgs_brin_minmax_multi_distance_time_Policy>({}); }
+struct TArgs_brin_minmax_multi_distance_timestamp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_gtsvector_penalty() { return &GenericExec<TPgDirectFunc<&gtsvector_penalty>, true, true, TArgs_gtsvector_penalty_Policy>; }
-struct TArgs_gtsvector_picksplit_Policy {
+TExecFunc arrow_brin_minmax_multi_distance_timestamp() { return TGenericExec<TPgDirectFunc<&brin_minmax_multi_distance_timestamp>, true, true, TArgs_brin_minmax_multi_distance_timestamp_Policy>({}); }
+struct TArgs_brin_minmax_multi_distance_timetz_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_gtsvector_picksplit() { return &GenericExec<TPgDirectFunc<&gtsvector_picksplit>, true, true, TArgs_gtsvector_picksplit_Policy>; }
-struct TArgs_gtsvector_same_Policy {
+TExecFunc arrow_brin_minmax_multi_distance_timetz() { return TGenericExec<TPgDirectFunc<&brin_minmax_multi_distance_timetz>, true, true, TArgs_brin_minmax_multi_distance_timetz_Policy>({}); }
+struct TArgs_brin_minmax_multi_distance_uuid_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_gtsvector_same() { return &GenericExec<TPgDirectFunc<&gtsvector_same>, true, true, TArgs_gtsvector_same_Policy>; }
-struct TArgs_gtsvector_union_Policy {
+TExecFunc arrow_brin_minmax_multi_distance_uuid() { return TGenericExec<TPgDirectFunc<&brin_minmax_multi_distance_uuid>, true, true, TArgs_brin_minmax_multi_distance_uuid_Policy>({}); }
+struct TArgs_brin_minmax_multi_opcinfo_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_gtsvector_union() { return &GenericExec<TPgDirectFunc<&gtsvector_union>, true, false, TArgs_gtsvector_union_Policy>; }
-struct TArgs_gtsvectorin_Policy {
+TExecFunc arrow_brin_minmax_multi_opcinfo() { return TGenericExec<TPgDirectFunc<&brin_minmax_multi_opcinfo>, true, true, TArgs_brin_minmax_multi_opcinfo_Policy>({}); }
+struct TArgs_brin_minmax_multi_options_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_gtsvectorin() { return &GenericExec<TPgDirectFunc<&gtsvectorin>, true, false, TArgs_gtsvectorin_Policy>; }
-struct TArgs_gtsvectorout_Policy {
+TExecFunc arrow_brin_minmax_multi_options() { return TGenericExec<TPgDirectFunc<&brin_minmax_multi_options>, false, true, TArgs_brin_minmax_multi_options_Policy>({}); }
+struct TArgs_brin_minmax_multi_summary_in_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_gtsvectorout() { return &GenericExec<TPgDirectFunc<&gtsvectorout>, true, false, TArgs_gtsvectorout_Policy>; }
-struct TArgs_hash_numeric_Policy {
+TExecFunc arrow_brin_minmax_multi_summary_in() { return TGenericExec<TPgDirectFunc<&brin_minmax_multi_summary_in>, true, false, TArgs_brin_minmax_multi_summary_in_Policy>({}); }
+struct TArgs_brin_minmax_multi_summary_out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_hash_numeric() { return &GenericExec<TPgDirectFunc<&hash_numeric>, true, true, TArgs_hash_numeric_Policy>; }
-struct TArgs_hash_numeric_extended_Policy {
+TExecFunc arrow_brin_minmax_multi_summary_out() { return TGenericExec<TPgDirectFunc<&brin_minmax_multi_summary_out>, true, false, TArgs_brin_minmax_multi_summary_out_Policy>({}); }
+struct TArgs_brin_minmax_multi_summary_recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_hash_numeric_extended() { return &GenericExec<TPgDirectFunc<&hash_numeric_extended>, true, true, TArgs_hash_numeric_extended_Policy>; }
-struct TArgs_hashmacaddr_Policy {
+TExecFunc arrow_brin_minmax_multi_summary_recv() { return TGenericExec<TPgDirectFunc<&brin_minmax_multi_summary_recv>, true, false, TArgs_brin_minmax_multi_summary_recv_Policy>({}); }
+struct TArgs_brin_minmax_multi_summary_send_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_hashmacaddr() { return &GenericExec<TPgDirectFunc<&hashmacaddr>, true, true, TArgs_hashmacaddr_Policy>; }
-struct TArgs_hashmacaddrextended_Policy {
+TExecFunc arrow_brin_minmax_multi_summary_send() { return TGenericExec<TPgDirectFunc<&brin_minmax_multi_summary_send>, true, false, TArgs_brin_minmax_multi_summary_send_Policy>({}); }
+struct TArgs_brin_minmax_multi_union_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_hashmacaddrextended() { return &GenericExec<TPgDirectFunc<&hashmacaddrextended>, true, true, TArgs_hashmacaddrextended_Policy>; }
-struct TArgs_i2toi4_Policy {
+TExecFunc arrow_brin_minmax_multi_union() { return TGenericExec<TPgDirectFunc<&brin_minmax_multi_union>, true, true, TArgs_brin_minmax_multi_union_Policy>({}); }
+struct TArgs_brin_summarize_new_values_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_i2toi4() { return &GenericExec<TPgDirectFunc<&i2toi4>, true, true, TArgs_i2toi4_Policy>; }
-struct TArgs_i4toi2_Policy {
+TExecFunc arrow_brin_summarize_new_values() { return TGenericExec<TPgDirectFunc<&brin_summarize_new_values>, true, true, TArgs_brin_summarize_new_values_Policy>({}); }
+struct TArgs_brin_summarize_range_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+};
+TExecFunc arrow_brin_summarize_range() { return TGenericExec<TPgDirectFunc<&brin_summarize_range>, true, true, TArgs_brin_summarize_range_Policy>({}); }
+struct TArgs_brinhandler_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_i4toi2() { return &GenericExec<TPgDirectFunc<&i4toi2>, true, true, TArgs_i4toi2_Policy>; }
-struct TArgs_iclikejoinsel_Policy {
+TExecFunc arrow_brinhandler() { return TGenericExec<TPgDirectFunc<&brinhandler>, true, true, TArgs_brinhandler_Policy>({}); }
+struct TArgs_btboolcmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_iclikejoinsel() { return &GenericExec<TPgDirectFunc<&iclikejoinsel>, true, true, TArgs_iclikejoinsel_Policy>; }
-struct TArgs_iclikesel_Policy {
+TExecFunc arrow_btboolcmp() { return TGenericExec<TPgDirectFunc<&btboolcmp>, true, true, TArgs_btboolcmp_Policy>({}); }
+struct TArgs_btcharcmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_iclikesel() { return &GenericExec<TPgDirectFunc<&iclikesel>, true, true, TArgs_iclikesel_Policy>; }
-struct TArgs_icnlikejoinsel_Policy {
+TExecFunc arrow_btcharcmp() { return TGenericExec<TPgDirectFunc<&btcharcmp>, true, true, TArgs_btcharcmp_Policy>({}); }
+struct TArgs_btint24cmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_icnlikejoinsel() { return &GenericExec<TPgDirectFunc<&icnlikejoinsel>, true, true, TArgs_icnlikejoinsel_Policy>; }
-struct TArgs_icnlikesel_Policy {
+TExecFunc arrow_btint24cmp() { return TGenericExec<TPgDirectFunc<&btint24cmp>, true, true, TArgs_btint24cmp_Policy>({}); }
+struct TArgs_btint28cmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_icnlikesel() { return &GenericExec<TPgDirectFunc<&icnlikesel>, true, true, TArgs_icnlikesel_Policy>; }
-struct TArgs_icregexeqjoinsel_Policy {
+TExecFunc arrow_btint28cmp() { return TGenericExec<TPgDirectFunc<&btint28cmp>, true, true, TArgs_btint28cmp_Policy>({}); }
+struct TArgs_btint2cmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_icregexeqjoinsel() { return &GenericExec<TPgDirectFunc<&icregexeqjoinsel>, true, true, TArgs_icregexeqjoinsel_Policy>; }
-struct TArgs_icregexeqsel_Policy {
+TExecFunc arrow_btint2cmp() { return TGenericExec<TPgDirectFunc<&btint2cmp>, true, true, TArgs_btint2cmp_Policy>({}); }
+struct TArgs_btint2sortsupport_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_icregexeqsel() { return &GenericExec<TPgDirectFunc<&icregexeqsel>, true, true, TArgs_icregexeqsel_Policy>; }
-struct TArgs_icregexnejoinsel_Policy {
+TExecFunc arrow_btint2sortsupport() { return TGenericExec<TPgDirectFunc<&btint2sortsupport>, true, true, TArgs_btint2sortsupport_Policy>({}); }
+struct TArgs_btint42cmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_icregexnejoinsel() { return &GenericExec<TPgDirectFunc<&icregexnejoinsel>, true, true, TArgs_icregexnejoinsel_Policy>; }
-struct TArgs_icregexnesel_Policy {
+TExecFunc arrow_btint42cmp() { return TGenericExec<TPgDirectFunc<&btint42cmp>, true, true, TArgs_btint42cmp_Policy>({}); }
+struct TArgs_btint48cmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_icregexnesel() { return &GenericExec<TPgDirectFunc<&icregexnesel>, true, true, TArgs_icregexnesel_Policy>; }
-struct TArgs_in_range_int2_int2_Policy {
+TExecFunc arrow_btint48cmp() { return TGenericExec<TPgDirectFunc<&btint48cmp>, true, true, TArgs_btint48cmp_Policy>({}); }
+struct TArgs_btint4cmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_in_range_int2_int2() { return &GenericExec<TPgDirectFunc<&in_range_int2_int2>, true, true, TArgs_in_range_int2_int2_Policy>; }
-struct TArgs_in_range_int2_int4_Policy {
+TExecFunc arrow_btint4cmp() { return TGenericExec<TPgDirectFunc<&btint4cmp>, true, true, TArgs_btint4cmp_Policy>({}); }
+struct TArgs_btint4sortsupport_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_in_range_int2_int4() { return &GenericExec<TPgDirectFunc<&in_range_int2_int4>, true, true, TArgs_in_range_int2_int4_Policy>; }
-struct TArgs_in_range_int2_int8_Policy {
+TExecFunc arrow_btint4sortsupport() { return TGenericExec<TPgDirectFunc<&btint4sortsupport>, true, true, TArgs_btint4sortsupport_Policy>({}); }
+struct TArgs_btint82cmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_in_range_int2_int8() { return &GenericExec<TPgDirectFunc<&in_range_int2_int8>, true, true, TArgs_in_range_int2_int8_Policy>; }
-struct TArgs_in_range_int4_int2_Policy {
+TExecFunc arrow_btint82cmp() { return TGenericExec<TPgDirectFunc<&btint82cmp>, true, true, TArgs_btint82cmp_Policy>({}); }
+struct TArgs_btint84cmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_in_range_int4_int2() { return &GenericExec<TPgDirectFunc<&in_range_int4_int2>, true, true, TArgs_in_range_int4_int2_Policy>; }
-struct TArgs_in_range_int4_int4_Policy {
+TExecFunc arrow_btint84cmp() { return TGenericExec<TPgDirectFunc<&btint84cmp>, true, true, TArgs_btint84cmp_Policy>({}); }
+struct TArgs_btint8cmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_in_range_int4_int4() { return &GenericExec<TPgDirectFunc<&in_range_int4_int4>, true, true, TArgs_in_range_int4_int4_Policy>; }
-struct TArgs_in_range_int4_int8_Policy {
+TExecFunc arrow_btint8cmp() { return TGenericExec<TPgDirectFunc<&btint8cmp>, true, true, TArgs_btint8cmp_Policy>({}); }
+struct TArgs_btint8sortsupport_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_in_range_int4_int8() { return &GenericExec<TPgDirectFunc<&in_range_int4_int8>, true, true, TArgs_in_range_int4_int8_Policy>; }
-struct TArgs_in_range_interval_interval_Policy {
+TExecFunc arrow_btint8sortsupport() { return TGenericExec<TPgDirectFunc<&btint8sortsupport>, true, true, TArgs_btint8sortsupport_Policy>({}); }
+struct TArgs_btoidcmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {false,false,false,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_in_range_interval_interval() { return &GenericExec<TPgDirectFunc<&in_range_interval_interval>, true, true, TArgs_in_range_interval_interval_Policy>; }
-struct TArgs_in_range_numeric_numeric_Policy {
+TExecFunc arrow_btoidcmp() { return TGenericExec<TPgDirectFunc<&btoidcmp>, true, true, TArgs_btoidcmp_Policy>({}); }
+struct TArgs_btoidsortsupport_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {false,false,false,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_in_range_numeric_numeric() { return &GenericExec<TPgDirectFunc<&in_range_numeric_numeric>, true, true, TArgs_in_range_numeric_numeric_Policy>; }
-struct TArgs_in_range_timestamp_interval_Policy {
+TExecFunc arrow_btoidsortsupport() { return TGenericExec<TPgDirectFunc<&btoidsortsupport>, true, true, TArgs_btoidsortsupport_Policy>({}); }
+struct TArgs_btoidvectorcmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,false,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_in_range_timestamp_interval() { return &GenericExec<TPgDirectFunc<&in_range_timestamp_interval>, true, true, TArgs_in_range_timestamp_interval_Policy>; }
-struct TArgs_in_range_timestamptz_interval_Policy {
+TExecFunc arrow_btoidvectorcmp() { return TGenericExec<TPgDirectFunc<&btoidvectorcmp>, true, true, TArgs_btoidvectorcmp_Policy>({}); }
+struct TArgs_btrim_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,false,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_in_range_timestamptz_interval() { return &GenericExec<TPgDirectFunc<&in_range_timestamptz_interval>, true, true, TArgs_in_range_timestamptz_interval_Policy>; }
-struct TArgs_index_am_handler_in_Policy {
+TExecFunc arrow_btrim() { return TGenericExec<TPgDirectFunc<&btrim>, true, false, TArgs_btrim_Policy>({}); }
+struct TArgs_btrim1_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_index_am_handler_in() { return &GenericExec<TPgDirectFunc<&index_am_handler_in>, false, true, TArgs_index_am_handler_in_Policy>; }
-struct TArgs_index_am_handler_out_Policy {
+TExecFunc arrow_btrim1() { return TGenericExec<TPgDirectFunc<&btrim1>, true, false, TArgs_btrim1_Policy>({}); }
+struct TArgs_bytealike_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_index_am_handler_out() { return &GenericExec<TPgDirectFunc<&index_am_handler_out>, true, false, TArgs_index_am_handler_out_Policy>; }
-struct TArgs_int24div_Policy {
+TExecFunc arrow_bytealike() { return TGenericExec<TPgDirectFunc<&bytealike>, true, true, TArgs_bytealike_Policy>({}); }
+struct TArgs_bytealtrim_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_int24div() { return &GenericExec<TPgDirectFunc<&int24div>, true, true, TArgs_int24div_Policy>; }
-struct TArgs_int24eq_Policy {
+TExecFunc arrow_bytealtrim() { return TGenericExec<TPgDirectFunc<&bytealtrim>, true, false, TArgs_bytealtrim_Policy>({}); }
+struct TArgs_byteanlike_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_int24eq() { return &GenericExec<TPgDirectFunc<&int24eq>, true, true, TArgs_int24eq_Policy>; }
-struct TArgs_int24ge_Policy {
+TExecFunc arrow_byteanlike() { return TGenericExec<TPgDirectFunc<&byteanlike>, true, true, TArgs_byteanlike_Policy>({}); }
+struct TArgs_byteartrim_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_int24ge() { return &GenericExec<TPgDirectFunc<&int24ge>, true, true, TArgs_int24ge_Policy>; }
-struct TArgs_int24gt_Policy {
+TExecFunc arrow_byteartrim() { return TGenericExec<TPgDirectFunc<&byteartrim>, true, false, TArgs_byteartrim_Policy>({}); }
+struct TArgs_byteatrim_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_int24gt() { return &GenericExec<TPgDirectFunc<&int24gt>, true, true, TArgs_int24gt_Policy>; }
-struct TArgs_int24le_Policy {
+TExecFunc arrow_byteatrim() { return TGenericExec<TPgDirectFunc<&byteatrim>, true, false, TArgs_byteatrim_Policy>({}); }
+struct TArgs_char_text_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int24le() { return &GenericExec<TPgDirectFunc<&int24le>, true, true, TArgs_int24le_Policy>; }
-struct TArgs_int24lt_Policy {
+TExecFunc arrow_char_text() { return TGenericExec<TPgDirectFunc<&char_text>, true, false, TArgs_char_text_Policy>({}); }
+struct TArgs_chareq_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int24lt() { return &GenericExec<TPgDirectFunc<&int24lt>, true, true, TArgs_int24lt_Policy>; }
-struct TArgs_int24mi_Policy {
+TExecFunc arrow_chareq() { return TGenericExec<TPgDirectFunc<&chareq>, true, true, TArgs_chareq_Policy>({}); }
+struct TArgs_charge_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int24mi() { return &GenericExec<TPgDirectFunc<&int24mi>, true, true, TArgs_int24mi_Policy>; }
-struct TArgs_int24mul_Policy {
+TExecFunc arrow_charge() { return TGenericExec<TPgDirectFunc<&charge>, true, true, TArgs_charge_Policy>({}); }
+struct TArgs_chargt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int24mul() { return &GenericExec<TPgDirectFunc<&int24mul>, true, true, TArgs_int24mul_Policy>; }
-struct TArgs_int24ne_Policy {
+TExecFunc arrow_chargt() { return TGenericExec<TPgDirectFunc<&chargt>, true, true, TArgs_chargt_Policy>({}); }
+struct TArgs_charin_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_int24ne() { return &GenericExec<TPgDirectFunc<&int24ne>, true, true, TArgs_int24ne_Policy>; }
-struct TArgs_int24pl_Policy {
+TExecFunc arrow_charin() { return TGenericExec<TPgDirectFunc<&charin>, true, true, TArgs_charin_Policy>({}); }
+struct TArgs_charle_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int24pl() { return &GenericExec<TPgDirectFunc<&int24pl>, true, true, TArgs_int24pl_Policy>; }
-struct TArgs_int2_accum_Policy {
+TExecFunc arrow_charle() { return TGenericExec<TPgDirectFunc<&charle>, true, true, TArgs_charle_Policy>({}); }
+struct TArgs_charlt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int2_accum() { return &GenericExec<TPgDirectFunc<&int2_accum>, false, true, TArgs_int2_accum_Policy>; }
-struct TArgs_int2_accum_inv_Policy {
+TExecFunc arrow_charlt() { return TGenericExec<TPgDirectFunc<&charlt>, true, true, TArgs_charlt_Policy>({}); }
+struct TArgs_charne_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int2_accum_inv() { return &GenericExec<TPgDirectFunc<&int2_accum_inv>, false, true, TArgs_int2_accum_inv_Policy>; }
-struct TArgs_int2_avg_accum_Policy {
+TExecFunc arrow_charne() { return TGenericExec<TPgDirectFunc<&charne>, true, true, TArgs_charne_Policy>({}); }
+struct TArgs_charout_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
-};
-TExecFunc arrow_int2_avg_accum() { return &GenericExec<TPgDirectFunc<&int2_avg_accum>, true, false, TArgs_int2_avg_accum_Policy>; }
-struct TArgs_int2_avg_accum_inv_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int2_avg_accum_inv() { return &GenericExec<TPgDirectFunc<&int2_avg_accum_inv>, true, false, TArgs_int2_avg_accum_inv_Policy>; }
-struct TArgs_int2_numeric_Policy {
+TExecFunc arrow_charout() { return TGenericExec<TPgDirectFunc<&charout>, true, false, TArgs_charout_Policy>({}); }
+struct TArgs_charrecv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int2_numeric() { return &GenericExec<TPgDirectFunc<&int2_numeric>, true, false, TArgs_int2_numeric_Policy>; }
-struct TArgs_int2_sum_Policy {
+TExecFunc arrow_charrecv() { return TGenericExec<TPgDirectFunc<&charrecv>, true, true, TArgs_charrecv_Policy>({}); }
+struct TArgs_charsend_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int2_sum() { return &GenericExec<TPgDirectFunc<&int2_sum>, false, true, TArgs_int2_sum_Policy>; }
-struct TArgs_int2abs_Policy {
+TExecFunc arrow_charsend() { return TGenericExec<TPgDirectFunc<&charsend>, true, false, TArgs_charsend_Policy>({}); }
+struct TArgs_chartoi4_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int2abs() { return &GenericExec<TPgDirectFunc<&int2abs>, true, true, TArgs_int2abs_Policy>; }
-struct TArgs_int2and_Policy {
+TExecFunc arrow_chartoi4() { return TGenericExec<TPgDirectFunc<&chartoi4>, true, true, TArgs_chartoi4_Policy>({}); }
+struct TArgs_chr_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int2and() { return &GenericExec<TPgDirectFunc<&int2and>, true, true, TArgs_int2and_Policy>; }
-struct TArgs_int2div_Policy {
+TExecFunc arrow_chr() { return TGenericExec<TPgDirectFunc<&chr>, true, false, TArgs_chr_Policy>({}); }
+struct TArgs_cidr_abbrev_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_int2div() { return &GenericExec<TPgDirectFunc<&int2div>, true, true, TArgs_int2div_Policy>; }
-struct TArgs_int2eq_Policy {
+TExecFunc arrow_cidr_abbrev() { return TGenericExec<TPgDirectFunc<&cidr_abbrev>, true, false, TArgs_cidr_abbrev_Policy>({}); }
+struct TArgs_cidr_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_int2eq() { return &GenericExec<TPgDirectFunc<&int2eq>, true, true, TArgs_int2eq_Policy>; }
-struct TArgs_int2ge_Policy {
+TExecFunc arrow_cidr_in() { return TGenericExec<TPgDirectFunc<&cidr_in>, true, false, TArgs_cidr_in_Policy>({}); }
+struct TArgs_cidr_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_int2ge() { return &GenericExec<TPgDirectFunc<&int2ge>, true, true, TArgs_int2ge_Policy>; }
-struct TArgs_int2gt_Policy {
+TExecFunc arrow_cidr_out() { return TGenericExec<TPgDirectFunc<&cidr_out>, true, false, TArgs_cidr_out_Policy>({}); }
+struct TArgs_cidr_recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int2gt() { return &GenericExec<TPgDirectFunc<&int2gt>, true, true, TArgs_int2gt_Policy>; }
-struct TArgs_int2in_Policy {
+TExecFunc arrow_cidr_recv() { return TGenericExec<TPgDirectFunc<&cidr_recv>, true, false, TArgs_cidr_recv_Policy>({}); }
+struct TArgs_cidr_send_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_int2in() { return &GenericExec<TPgDirectFunc<&int2in>, true, true, TArgs_int2in_Policy>; }
-struct TArgs_int2int4_sum_Policy {
+TExecFunc arrow_cidr_send() { return TGenericExec<TPgDirectFunc<&cidr_send>, true, false, TArgs_cidr_send_Policy>({}); }
+struct TArgs_cidr_set_masklen_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_int2int4_sum() { return &GenericExec<TPgDirectFunc<&int2int4_sum>, true, true, TArgs_int2int4_sum_Policy>; }
-struct TArgs_int2larger_Policy {
+TExecFunc arrow_cidr_set_masklen() { return TGenericExec<TPgDirectFunc<&cidr_set_masklen>, true, false, TArgs_cidr_set_masklen_Policy>({}); }
+struct TArgs_daterange_canonical_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_int2larger() { return &GenericExec<TPgDirectFunc<&int2larger>, true, true, TArgs_int2larger_Policy>; }
-struct TArgs_int2le_Policy {
+TExecFunc arrow_daterange_canonical() { return TGenericExec<TPgDirectFunc<&daterange_canonical>, true, false, TArgs_daterange_canonical_Policy>({}); }
+struct TArgs_daterange_subdiff_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int2le() { return &GenericExec<TPgDirectFunc<&int2le>, true, true, TArgs_int2le_Policy>; }
-struct TArgs_int2lt_Policy {
+TExecFunc arrow_daterange_subdiff() { return TGenericExec<TPgDirectFunc<&daterange_subdiff>, true, true, TArgs_daterange_subdiff_Policy>({}); }
+struct TArgs_elem_contained_by_range_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_int2lt() { return &GenericExec<TPgDirectFunc<&int2lt>, true, true, TArgs_int2lt_Policy>; }
-struct TArgs_int2mi_Policy {
+TExecFunc arrow_elem_contained_by_range() { return TGenericExec<TPgDirectFunc<&elem_contained_by_range>, true, true, TArgs_elem_contained_by_range_Policy>({}); }
+struct TArgs_enum_cmp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int2mi() { return &GenericExec<TPgDirectFunc<&int2mi>, true, true, TArgs_int2mi_Policy>; }
-struct TArgs_int2mod_Policy {
+TExecFunc arrow_enum_cmp() { return TGenericExec<TPgDirectFunc<&enum_cmp>, true, true, TArgs_enum_cmp_Policy>({}); }
+struct TArgs_enum_eq_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int2mod() { return &GenericExec<TPgDirectFunc<&int2mod>, true, true, TArgs_int2mod_Policy>; }
-struct TArgs_int2mul_Policy {
+TExecFunc arrow_enum_eq() { return TGenericExec<TPgDirectFunc<&enum_eq>, true, true, TArgs_enum_eq_Policy>({}); }
+struct TArgs_enum_first_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int2mul() { return &GenericExec<TPgDirectFunc<&int2mul>, true, true, TArgs_int2mul_Policy>; }
-struct TArgs_int2ne_Policy {
+TExecFunc arrow_enum_first() { return TGenericExec<TPgDirectFunc<&enum_first>, false, true, TArgs_enum_first_Policy>({}); }
+struct TArgs_enum_ge_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int2ne() { return &GenericExec<TPgDirectFunc<&int2ne>, true, true, TArgs_int2ne_Policy>; }
-struct TArgs_int2not_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_int2not() { return &GenericExec<TPgDirectFunc<&int2not>, true, true, TArgs_int2not_Policy>; }
-struct TArgs_int2or_Policy {
+TExecFunc arrow_enum_ge() { return TGenericExec<TPgDirectFunc<&enum_ge>, true, true, TArgs_enum_ge_Policy>({}); }
+struct TArgs_enum_gt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int2or() { return &GenericExec<TPgDirectFunc<&int2or>, true, true, TArgs_int2or_Policy>; }
-struct TArgs_int2out_Policy {
+TExecFunc arrow_enum_gt() { return TGenericExec<TPgDirectFunc<&enum_gt>, true, true, TArgs_enum_gt_Policy>({}); }
+struct TArgs_enum_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_int2out() { return &GenericExec<TPgDirectFunc<&int2out>, true, false, TArgs_int2out_Policy>; }
-struct TArgs_int2pl_Policy {
+TExecFunc arrow_enum_in() { return TGenericExec<TPgDirectFunc<&enum_in>, true, true, TArgs_enum_in_Policy>({}); }
+struct TArgs_enum_larger_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int2pl() { return &GenericExec<TPgDirectFunc<&int2pl>, true, true, TArgs_int2pl_Policy>; }
-struct TArgs_int2recv_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_int2recv() { return &GenericExec<TPgDirectFunc<&int2recv>, true, true, TArgs_int2recv_Policy>; }
-struct TArgs_int2send_Policy {
+TExecFunc arrow_enum_larger() { return TGenericExec<TPgDirectFunc<&enum_larger>, true, true, TArgs_enum_larger_Policy>({}); }
+struct TArgs_enum_last_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int2send() { return &GenericExec<TPgDirectFunc<&int2send>, true, false, TArgs_int2send_Policy>; }
-struct TArgs_int2shl_Policy {
+TExecFunc arrow_enum_last() { return TGenericExec<TPgDirectFunc<&enum_last>, false, true, TArgs_enum_last_Policy>({}); }
+struct TArgs_enum_le_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int2shl() { return &GenericExec<TPgDirectFunc<&int2shl>, true, true, TArgs_int2shl_Policy>; }
-struct TArgs_int2shr_Policy {
+TExecFunc arrow_enum_le() { return TGenericExec<TPgDirectFunc<&enum_le>, true, true, TArgs_enum_le_Policy>({}); }
+struct TArgs_enum_lt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int2shr() { return &GenericExec<TPgDirectFunc<&int2shr>, true, true, TArgs_int2shr_Policy>; }
-struct TArgs_int2smaller_Policy {
+TExecFunc arrow_enum_lt() { return TGenericExec<TPgDirectFunc<&enum_lt>, true, true, TArgs_enum_lt_Policy>({}); }
+struct TArgs_enum_ne_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int2smaller() { return &GenericExec<TPgDirectFunc<&int2smaller>, true, true, TArgs_int2smaller_Policy>; }
-struct TArgs_int2um_Policy {
+TExecFunc arrow_enum_ne() { return TGenericExec<TPgDirectFunc<&enum_ne>, true, true, TArgs_enum_ne_Policy>({}); }
+struct TArgs_enum_out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int2um() { return &GenericExec<TPgDirectFunc<&int2um>, true, true, TArgs_int2um_Policy>; }
-struct TArgs_int2up_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_int2up() { return &GenericExec<TPgDirectFunc<&int2up>, true, true, TArgs_int2up_Policy>; }
-struct TArgs_int2vectorin_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_int2vectorin() { return &GenericExec<TPgDirectFunc<&int2vectorin>, true, false, TArgs_int2vectorin_Policy>; }
-struct TArgs_int2vectorout_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_int2vectorout() { return &GenericExec<TPgDirectFunc<&int2vectorout>, true, false, TArgs_int2vectorout_Policy>; }
-struct TArgs_int2vectorrecv_Policy {
+TExecFunc arrow_enum_out() { return TGenericExec<TPgDirectFunc<&enum_out>, true, false, TArgs_enum_out_Policy>({}); }
+struct TArgs_enum_range_all_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int2vectorrecv() { return &GenericExec<TPgDirectFunc<&int2vectorrecv>, true, false, TArgs_int2vectorrecv_Policy>; }
-struct TArgs_int2vectorsend_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_int2vectorsend() { return &GenericExec<TPgDirectFunc<&int2vectorsend>, true, false, TArgs_int2vectorsend_Policy>; }
-struct TArgs_int2xor_Policy {
+TExecFunc arrow_enum_range_all() { return TGenericExec<TPgDirectFunc<&enum_range_all>, false, false, TArgs_enum_range_all_Policy>({}); }
+struct TArgs_enum_range_bounds_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int2xor() { return &GenericExec<TPgDirectFunc<&int2xor>, true, true, TArgs_int2xor_Policy>; }
-struct TArgs_int42div_Policy {
+TExecFunc arrow_enum_range_bounds() { return TGenericExec<TPgDirectFunc<&enum_range_bounds>, false, false, TArgs_enum_range_bounds_Policy>({}); }
+struct TArgs_enum_recv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int42div() { return &GenericExec<TPgDirectFunc<&int42div>, true, true, TArgs_int42div_Policy>; }
-struct TArgs_int42eq_Policy {
+TExecFunc arrow_enum_recv() { return TGenericExec<TPgDirectFunc<&enum_recv>, true, true, TArgs_enum_recv_Policy>({}); }
+struct TArgs_enum_send_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int42eq() { return &GenericExec<TPgDirectFunc<&int42eq>, true, true, TArgs_int42eq_Policy>; }
-struct TArgs_int42ge_Policy {
+TExecFunc arrow_enum_send() { return TGenericExec<TPgDirectFunc<&enum_send>, true, false, TArgs_enum_send_Policy>({}); }
+struct TArgs_enum_smaller_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int42ge() { return &GenericExec<TPgDirectFunc<&int42ge>, true, true, TArgs_int42ge_Policy>; }
-struct TArgs_int42gt_Policy {
+TExecFunc arrow_enum_smaller() { return TGenericExec<TPgDirectFunc<&enum_smaller>, true, true, TArgs_enum_smaller_Policy>({}); }
+struct TArgs_eqjoinsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
 };
-TExecFunc arrow_int42gt() { return &GenericExec<TPgDirectFunc<&int42gt>, true, true, TArgs_int42gt_Policy>; }
-struct TArgs_int42le_Policy {
+TExecFunc arrow_eqjoinsel() { return TGenericExec<TPgDirectFunc<&eqjoinsel>, true, true, TArgs_eqjoinsel_Policy>({}); }
+struct TArgs_eqsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_int42le() { return &GenericExec<TPgDirectFunc<&int42le>, true, true, TArgs_int42le_Policy>; }
-struct TArgs_int42lt_Policy {
+TExecFunc arrow_eqsel() { return TGenericExec<TPgDirectFunc<&eqsel>, true, true, TArgs_eqsel_Policy>({}); }
+struct TArgs_fmgr_c_validator_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int42lt() { return &GenericExec<TPgDirectFunc<&int42lt>, true, true, TArgs_int42lt_Policy>; }
-struct TArgs_int42mi_Policy {
+TExecFunc arrow_fmgr_c_validator() { return TGenericExec<TPgDirectFunc<&fmgr_c_validator>, true, true, TArgs_fmgr_c_validator_Policy>({}); }
+struct TArgs_fmgr_internal_validator_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int42mi() { return &GenericExec<TPgDirectFunc<&int42mi>, true, true, TArgs_int42mi_Policy>; }
-struct TArgs_int42mul_Policy {
+TExecFunc arrow_fmgr_internal_validator() { return TGenericExec<TPgDirectFunc<&fmgr_internal_validator>, true, true, TArgs_fmgr_internal_validator_Policy>({}); }
+struct TArgs_fmgr_sql_validator_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int42mul() { return &GenericExec<TPgDirectFunc<&int42mul>, true, true, TArgs_int42mul_Policy>; }
-struct TArgs_int42ne_Policy {
+TExecFunc arrow_fmgr_sql_validator() { return TGenericExec<TPgDirectFunc<&fmgr_sql_validator>, true, true, TArgs_fmgr_sql_validator_Policy>({}); }
+struct TArgs_format_type_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int42ne() { return &GenericExec<TPgDirectFunc<&int42ne>, true, true, TArgs_int42ne_Policy>; }
-struct TArgs_int42pl_Policy {
+TExecFunc arrow_format_type() { return TGenericExec<TPgDirectFunc<&format_type>, false, false, TArgs_format_type_Policy>({}); }
+struct TArgs_gen_random_uuid_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_int42pl() { return &GenericExec<TPgDirectFunc<&int42pl>, true, true, TArgs_int42pl_Policy>; }
-struct TArgs_int4_accum_Policy {
+TExecFunc arrow_gen_random_uuid() { return TGenericExec<TPgDirectFunc<&gen_random_uuid>, true, false, TArgs_gen_random_uuid_Policy>({}); }
+struct TArgs_getdatabaseencoding_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_int4_accum() { return &GenericExec<TPgDirectFunc<&int4_accum>, false, true, TArgs_int4_accum_Policy>; }
-struct TArgs_int4_accum_inv_Policy {
+TExecFunc arrow_getdatabaseencoding() { return TGenericExec<TPgDirectFunc<&getdatabaseencoding>, true, false, TArgs_getdatabaseencoding_Policy>({}); }
+struct TArgs_gisthandler_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int4_accum_inv() { return &GenericExec<TPgDirectFunc<&int4_accum_inv>, false, true, TArgs_int4_accum_inv_Policy>; }
-struct TArgs_int4_avg_accum_Policy {
+TExecFunc arrow_gisthandler() { return TGenericExec<TPgDirectFunc<&gisthandler>, true, true, TArgs_gisthandler_Policy>({}); }
+struct TArgs_gtsvector_compress_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int4_avg_accum() { return &GenericExec<TPgDirectFunc<&int4_avg_accum>, true, false, TArgs_int4_avg_accum_Policy>; }
-struct TArgs_int4_avg_accum_inv_Policy {
+TExecFunc arrow_gtsvector_compress() { return TGenericExec<TPgDirectFunc<&gtsvector_compress>, true, true, TArgs_gtsvector_compress_Policy>({}); }
+struct TArgs_gtsvector_consistent_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,false,true,true,true};
 };
-TExecFunc arrow_int4_avg_accum_inv() { return &GenericExec<TPgDirectFunc<&int4_avg_accum_inv>, true, false, TArgs_int4_avg_accum_inv_Policy>; }
-struct TArgs_int4_avg_combine_Policy {
+TExecFunc arrow_gtsvector_consistent() { return TGenericExec<TPgDirectFunc<&gtsvector_consistent>, true, true, TArgs_gtsvector_consistent_Policy>({}); }
+struct TArgs_gtsvector_consistent_oldsig_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,false,true,true,true};
 };
-TExecFunc arrow_int4_avg_combine() { return &GenericExec<TPgDirectFunc<&int4_avg_combine>, true, false, TArgs_int4_avg_combine_Policy>; }
-struct TArgs_int4_bool_Policy {
+TExecFunc arrow_gtsvector_consistent_oldsig() { return TGenericExec<TPgDirectFunc<&gtsvector_consistent_oldsig>, true, true, TArgs_gtsvector_consistent_oldsig_Policy>({}); }
+struct TArgs_gtsvector_decompress_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int4_bool() { return &GenericExec<TPgDirectFunc<&int4_bool>, true, true, TArgs_int4_bool_Policy>; }
-struct TArgs_int4_numeric_Policy {
+TExecFunc arrow_gtsvector_decompress() { return TGenericExec<TPgDirectFunc<&gtsvector_decompress>, true, true, TArgs_gtsvector_decompress_Policy>({}); }
+struct TArgs_gtsvector_options_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int4_numeric() { return &GenericExec<TPgDirectFunc<&int4_numeric>, true, false, TArgs_int4_numeric_Policy>; }
-struct TArgs_int4_sum_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
-};
-TExecFunc arrow_int4_sum() { return &GenericExec<TPgDirectFunc<&int4_sum>, false, true, TArgs_int4_sum_Policy>; }
-struct TArgs_int4abs_Policy {
+TExecFunc arrow_gtsvector_options() { return TGenericExec<TPgDirectFunc<&gtsvector_options>, false, true, TArgs_gtsvector_options_Policy>({}); }
+struct TArgs_gtsvector_penalty_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_int4abs() { return &GenericExec<TPgDirectFunc<&int4abs>, true, true, TArgs_int4abs_Policy>; }
-struct TArgs_int4and_Policy {
+TExecFunc arrow_gtsvector_penalty() { return TGenericExec<TPgDirectFunc<&gtsvector_penalty>, true, true, TArgs_gtsvector_penalty_Policy>({}); }
+struct TArgs_gtsvector_picksplit_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int4and() { return &GenericExec<TPgDirectFunc<&int4and>, true, true, TArgs_int4and_Policy>; }
-struct TArgs_int4div_Policy {
+TExecFunc arrow_gtsvector_picksplit() { return TGenericExec<TPgDirectFunc<&gtsvector_picksplit>, true, true, TArgs_gtsvector_picksplit_Policy>({}); }
+struct TArgs_gtsvector_same_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,true};
 };
-TExecFunc arrow_int4div() { return &GenericExec<TPgDirectFunc<&int4div>, true, true, TArgs_int4div_Policy>; }
-struct TArgs_int4eq_Policy {
+TExecFunc arrow_gtsvector_same() { return TGenericExec<TPgDirectFunc<&gtsvector_same>, true, true, TArgs_gtsvector_same_Policy>({}); }
+struct TArgs_gtsvector_union_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int4eq() { return &GenericExec<TPgDirectFunc<&int4eq>, true, true, TArgs_int4eq_Policy>; }
-struct TArgs_int4gcd_Policy {
+TExecFunc arrow_gtsvector_union() { return TGenericExec<TPgDirectFunc<&gtsvector_union>, true, false, TArgs_gtsvector_union_Policy>({}); }
+struct TArgs_gtsvectorin_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_int4gcd() { return &GenericExec<TPgDirectFunc<&int4gcd>, true, true, TArgs_int4gcd_Policy>; }
-struct TArgs_int4ge_Policy {
+TExecFunc arrow_gtsvectorin() { return TGenericExec<TPgDirectFunc<&gtsvectorin>, true, false, TArgs_gtsvectorin_Policy>({}); }
+struct TArgs_gtsvectorout_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_int4ge() { return &GenericExec<TPgDirectFunc<&int4ge>, true, true, TArgs_int4ge_Policy>; }
-struct TArgs_int4gt_Policy {
+TExecFunc arrow_gtsvectorout() { return TGenericExec<TPgDirectFunc<&gtsvectorout>, true, false, TArgs_gtsvectorout_Policy>({}); }
+struct TArgs_hash_range_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_int4gt() { return &GenericExec<TPgDirectFunc<&int4gt>, true, true, TArgs_int4gt_Policy>; }
-struct TArgs_int4in_Policy {
+TExecFunc arrow_hash_range() { return TGenericExec<TPgDirectFunc<&hash_range>, true, true, TArgs_hash_range_Policy>({}); }
+struct TArgs_hash_range_extended_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_int4in() { return &GenericExec<TPgDirectFunc<&int4in>, true, true, TArgs_int4in_Policy>; }
-struct TArgs_int4inc_Policy {
+TExecFunc arrow_hash_range_extended() { return TGenericExec<TPgDirectFunc<&hash_range_extended>, true, true, TArgs_hash_range_extended_Policy>({}); }
+struct TArgs_hashchar_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int4inc() { return &GenericExec<TPgDirectFunc<&int4inc>, true, true, TArgs_int4inc_Policy>; }
-struct TArgs_int4larger_Policy {
+TExecFunc arrow_hashchar() { return TGenericExec<TPgDirectFunc<&hashchar>, true, true, TArgs_hashchar_Policy>({}); }
+struct TArgs_hashcharextended_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int4larger() { return &GenericExec<TPgDirectFunc<&int4larger>, true, true, TArgs_int4larger_Policy>; }
-struct TArgs_int4lcm_Policy {
+TExecFunc arrow_hashcharextended() { return TGenericExec<TPgDirectFunc<&hashcharextended>, true, true, TArgs_hashcharextended_Policy>({}); }
+struct TArgs_hashenum_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int4lcm() { return &GenericExec<TPgDirectFunc<&int4lcm>, true, true, TArgs_int4lcm_Policy>; }
-struct TArgs_int4le_Policy {
+TExecFunc arrow_hashenum() { return TGenericExec<TPgDirectFunc<&hashenum>, true, true, TArgs_hashenum_Policy>({}); }
+struct TArgs_hashenumextended_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int4le() { return &GenericExec<TPgDirectFunc<&int4le>, true, true, TArgs_int4le_Policy>; }
-struct TArgs_int4lt_Policy {
+TExecFunc arrow_hashenumextended() { return TGenericExec<TPgDirectFunc<&hashenumextended>, true, true, TArgs_hashenumextended_Policy>({}); }
+struct TArgs_hashfloat4_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int4lt() { return &GenericExec<TPgDirectFunc<&int4lt>, true, true, TArgs_int4lt_Policy>; }
-struct TArgs_int4mi_Policy {
+TExecFunc arrow_hashfloat4() { return TGenericExec<TPgDirectFunc<&hashfloat4>, true, true, TArgs_hashfloat4_Policy>({}); }
+struct TArgs_hashfloat4extended_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int4mi() { return &GenericExec<TPgDirectFunc<&int4mi>, true, true, TArgs_int4mi_Policy>; }
-struct TArgs_int4mod_Policy {
+TExecFunc arrow_hashfloat4extended() { return TGenericExec<TPgDirectFunc<&hashfloat4extended>, true, true, TArgs_hashfloat4extended_Policy>({}); }
+struct TArgs_hashfloat8_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int4mod() { return &GenericExec<TPgDirectFunc<&int4mod>, true, true, TArgs_int4mod_Policy>; }
-struct TArgs_int4mul_Policy {
+TExecFunc arrow_hashfloat8() { return TGenericExec<TPgDirectFunc<&hashfloat8>, true, true, TArgs_hashfloat8_Policy>({}); }
+struct TArgs_hashfloat8extended_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int4mul() { return &GenericExec<TPgDirectFunc<&int4mul>, true, true, TArgs_int4mul_Policy>; }
-struct TArgs_int4ne_Policy {
+TExecFunc arrow_hashfloat8extended() { return TGenericExec<TPgDirectFunc<&hashfloat8extended>, true, true, TArgs_hashfloat8extended_Policy>({}); }
+struct TArgs_hashinet_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_int4ne() { return &GenericExec<TPgDirectFunc<&int4ne>, true, true, TArgs_int4ne_Policy>; }
-struct TArgs_int4not_Policy {
+TExecFunc arrow_hashinet() { return TGenericExec<TPgDirectFunc<&hashinet>, true, true, TArgs_hashinet_Policy>({}); }
+struct TArgs_hashinetextended_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+};
+TExecFunc arrow_hashinetextended() { return TGenericExec<TPgDirectFunc<&hashinetextended>, true, true, TArgs_hashinetextended_Policy>({}); }
+struct TArgs_hashint2_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int4not() { return &GenericExec<TPgDirectFunc<&int4not>, true, true, TArgs_int4not_Policy>; }
-struct TArgs_int4or_Policy {
+TExecFunc arrow_hashint2() { return TGenericExec<TPgDirectFunc<&hashint2>, true, true, TArgs_hashint2_Policy>({}); }
+struct TArgs_hashint2extended_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int4or() { return &GenericExec<TPgDirectFunc<&int4or>, true, true, TArgs_int4or_Policy>; }
-struct TArgs_int4out_Policy {
+TExecFunc arrow_hashint2extended() { return TGenericExec<TPgDirectFunc<&hashint2extended>, true, true, TArgs_hashint2extended_Policy>({}); }
+struct TArgs_hashint4_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int4out() { return &GenericExec<TPgDirectFunc<&int4out>, true, false, TArgs_int4out_Policy>; }
-struct TArgs_int4pl_Policy {
+TExecFunc arrow_hashint4() { return TGenericExec<TPgDirectFunc<&hashint4>, true, true, TArgs_hashint4_Policy>({}); }
+struct TArgs_hashint4extended_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int4pl() { return &GenericExec<TPgDirectFunc<&int4pl>, true, true, TArgs_int4pl_Policy>; }
-struct TArgs_int4recv_Policy {
+TExecFunc arrow_hashint4extended() { return TGenericExec<TPgDirectFunc<&hashint4extended>, true, true, TArgs_hashint4extended_Policy>({}); }
+struct TArgs_hashint8_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int4recv() { return &GenericExec<TPgDirectFunc<&int4recv>, true, true, TArgs_int4recv_Policy>; }
-struct TArgs_int4send_Policy {
+TExecFunc arrow_hashint8() { return TGenericExec<TPgDirectFunc<&hashint8>, true, true, TArgs_hashint8_Policy>({}); }
+struct TArgs_hashint8extended_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int4send() { return &GenericExec<TPgDirectFunc<&int4send>, true, false, TArgs_int4send_Policy>; }
-struct TArgs_int4shl_Policy {
+TExecFunc arrow_hashint8extended() { return TGenericExec<TPgDirectFunc<&hashint8extended>, true, true, TArgs_hashint8extended_Policy>({}); }
+struct TArgs_hashmacaddr8_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_int4shl() { return &GenericExec<TPgDirectFunc<&int4shl>, true, true, TArgs_int4shl_Policy>; }
-struct TArgs_int4shr_Policy {
+TExecFunc arrow_hashmacaddr8() { return TGenericExec<TPgDirectFunc<&hashmacaddr8>, true, true, TArgs_hashmacaddr8_Policy>({}); }
+struct TArgs_hashmacaddr8extended_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_int4shr() { return &GenericExec<TPgDirectFunc<&int4shr>, true, true, TArgs_int4shr_Policy>; }
-struct TArgs_int4smaller_Policy {
+TExecFunc arrow_hashmacaddr8extended() { return TGenericExec<TPgDirectFunc<&hashmacaddr8extended>, true, true, TArgs_hashmacaddr8extended_Policy>({}); }
+struct TArgs_hashname_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_int4smaller() { return &GenericExec<TPgDirectFunc<&int4smaller>, true, true, TArgs_int4smaller_Policy>; }
-struct TArgs_int4um_Policy {
+TExecFunc arrow_hashname() { return TGenericExec<TPgDirectFunc<&hashname>, true, true, TArgs_hashname_Policy>({}); }
+struct TArgs_hashnameextended_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_int4um() { return &GenericExec<TPgDirectFunc<&int4um>, true, true, TArgs_int4um_Policy>; }
-struct TArgs_int4up_Policy {
+TExecFunc arrow_hashnameextended() { return TGenericExec<TPgDirectFunc<&hashnameextended>, true, true, TArgs_hashnameextended_Policy>({}); }
+struct TArgs_hashoid_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int4up() { return &GenericExec<TPgDirectFunc<&int4up>, true, true, TArgs_int4up_Policy>; }
-struct TArgs_int4xor_Policy {
+TExecFunc arrow_hashoid() { return TGenericExec<TPgDirectFunc<&hashoid>, true, true, TArgs_hashoid_Policy>({}); }
+struct TArgs_hashoidextended_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int4xor() { return &GenericExec<TPgDirectFunc<&int4xor>, true, true, TArgs_int4xor_Policy>; }
-struct TArgs_int8_accum_Policy {
+TExecFunc arrow_hashoidextended() { return TGenericExec<TPgDirectFunc<&hashoidextended>, true, true, TArgs_hashoidextended_Policy>({}); }
+struct TArgs_hashoidvector_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_int8_accum() { return &GenericExec<TPgDirectFunc<&int8_accum>, false, true, TArgs_int8_accum_Policy>; }
-struct TArgs_int8_accum_inv_Policy {
+TExecFunc arrow_hashoidvector() { return TGenericExec<TPgDirectFunc<&hashoidvector>, true, true, TArgs_hashoidvector_Policy>({}); }
+struct TArgs_hashoidvectorextended_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_int8_accum_inv() { return &GenericExec<TPgDirectFunc<&int8_accum_inv>, false, true, TArgs_int8_accum_inv_Policy>; }
-struct TArgs_int8_avg_Policy {
+TExecFunc arrow_hashoidvectorextended() { return TGenericExec<TPgDirectFunc<&hashoidvectorextended>, true, true, TArgs_hashoidvectorextended_Policy>({}); }
+struct TArgs_hashtext_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_int8_avg() { return &GenericExec<TPgDirectFunc<&int8_avg>, true, false, TArgs_int8_avg_Policy>; }
-struct TArgs_int8_avg_accum_Policy {
+TExecFunc arrow_hashtext() { return TGenericExec<TPgDirectFunc<&hashtext>, true, true, TArgs_hashtext_Policy>({}); }
+struct TArgs_hashtextextended_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_int8_avg_accum() { return &GenericExec<TPgDirectFunc<&int8_avg_accum>, false, true, TArgs_int8_avg_accum_Policy>; }
-struct TArgs_int8_avg_accum_inv_Policy {
+TExecFunc arrow_hashtextextended() { return TGenericExec<TPgDirectFunc<&hashtextextended>, true, true, TArgs_hashtextextended_Policy>({}); }
+struct TArgs_hashvarlena_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int8_avg_accum_inv() { return &GenericExec<TPgDirectFunc<&int8_avg_accum_inv>, false, true, TArgs_int8_avg_accum_inv_Policy>; }
-struct TArgs_int8_avg_combine_Policy {
+TExecFunc arrow_hashvarlena() { return TGenericExec<TPgDirectFunc<&hashvarlena>, true, true, TArgs_hashvarlena_Policy>({}); }
+struct TArgs_hashvarlenaextended_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int8_avg_combine() { return &GenericExec<TPgDirectFunc<&int8_avg_combine>, false, true, TArgs_int8_avg_combine_Policy>; }
-struct TArgs_int8_avg_deserialize_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
-};
-TExecFunc arrow_int8_avg_deserialize() { return &GenericExec<TPgDirectFunc<&int8_avg_deserialize>, true, true, TArgs_int8_avg_deserialize_Policy>; }
-struct TArgs_int8_avg_serialize_Policy {
+TExecFunc arrow_hashvarlenaextended() { return TGenericExec<TPgDirectFunc<&hashvarlenaextended>, true, true, TArgs_hashvarlenaextended_Policy>({}); }
+struct TArgs_heap_tableam_handler_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int8_avg_serialize() { return &GenericExec<TPgDirectFunc<&int8_avg_serialize>, true, false, TArgs_int8_avg_serialize_Policy>; }
-struct TArgs_int8_numeric_Policy {
+TExecFunc arrow_heap_tableam_handler() { return TGenericExec<TPgDirectFunc<&heap_tableam_handler>, true, true, TArgs_heap_tableam_handler_Policy>({}); }
+struct TArgs_i4tochar_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int8_numeric() { return &GenericExec<TPgDirectFunc<&int8_numeric>, true, false, TArgs_int8_numeric_Policy>; }
-struct TArgs_int8_sum_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
-};
-TExecFunc arrow_int8_sum() { return &GenericExec<TPgDirectFunc<&int8_sum>, false, false, TArgs_int8_sum_Policy>; }
-struct TArgs_internal_in_Policy {
+TExecFunc arrow_i4tochar() { return TGenericExec<TPgDirectFunc<&i4tochar>, true, true, TArgs_i4tochar_Policy>({}); }
+struct TArgs_inet_abbrev_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_internal_in() { return &GenericExec<TPgDirectFunc<&internal_in>, false, true, TArgs_internal_in_Policy>; }
-struct TArgs_internal_out_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_internal_out() { return &GenericExec<TPgDirectFunc<&internal_out>, true, false, TArgs_internal_out_Policy>; }
-struct TArgs_interval_accum_Policy {
+TExecFunc arrow_inet_abbrev() { return TGenericExec<TPgDirectFunc<&inet_abbrev>, true, false, TArgs_inet_abbrev_Policy>({}); }
+struct TArgs_inet_client_addr_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_interval_accum() { return &GenericExec<TPgDirectFunc<&interval_accum>, true, false, TArgs_interval_accum_Policy>; }
-struct TArgs_interval_accum_inv_Policy {
+TExecFunc arrow_inet_client_addr() { return TGenericExec<TPgDirectFunc<&inet_client_addr>, false, false, TArgs_inet_client_addr_Policy>({}); }
+struct TArgs_inet_client_port_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_interval_accum_inv() { return &GenericExec<TPgDirectFunc<&interval_accum_inv>, true, false, TArgs_interval_accum_inv_Policy>; }
-struct TArgs_interval_avg_Policy {
+TExecFunc arrow_inet_client_port() { return TGenericExec<TPgDirectFunc<&inet_client_port>, false, true, TArgs_inet_client_port_Policy>({}); }
+struct TArgs_inet_in_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_interval_avg() { return &GenericExec<TPgDirectFunc<&interval_avg>, true, false, TArgs_interval_avg_Policy>; }
-struct TArgs_interval_cmp_Policy {
+TExecFunc arrow_inet_in() { return TGenericExec<TPgDirectFunc<&inet_in>, true, false, TArgs_inet_in_Policy>({}); }
+struct TArgs_inet_merge_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_interval_cmp() { return &GenericExec<TPgDirectFunc<&interval_cmp>, true, true, TArgs_interval_cmp_Policy>; }
-struct TArgs_interval_combine_Policy {
+TExecFunc arrow_inet_merge() { return TGenericExec<TPgDirectFunc<&inet_merge>, true, false, TArgs_inet_merge_Policy>({}); }
+struct TArgs_inet_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_interval_combine() { return &GenericExec<TPgDirectFunc<&interval_combine>, true, false, TArgs_interval_combine_Policy>; }
-struct TArgs_interval_div_Policy {
+TExecFunc arrow_inet_out() { return TGenericExec<TPgDirectFunc<&inet_out>, true, false, TArgs_inet_out_Policy>({}); }
+struct TArgs_inet_recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_interval_div() { return &GenericExec<TPgDirectFunc<&interval_div>, true, false, TArgs_interval_div_Policy>; }
-struct TArgs_interval_eq_Policy {
+TExecFunc arrow_inet_recv() { return TGenericExec<TPgDirectFunc<&inet_recv>, true, false, TArgs_inet_recv_Policy>({}); }
+struct TArgs_inet_same_family_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_interval_eq() { return &GenericExec<TPgDirectFunc<&interval_eq>, true, true, TArgs_interval_eq_Policy>; }
-struct TArgs_interval_finite_Policy {
+TExecFunc arrow_inet_same_family() { return TGenericExec<TPgDirectFunc<&inet_same_family>, true, true, TArgs_inet_same_family_Policy>({}); }
+struct TArgs_inet_send_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_interval_finite() { return &GenericExec<TPgDirectFunc<&interval_finite>, true, true, TArgs_interval_finite_Policy>; }
-struct TArgs_interval_ge_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_interval_ge() { return &GenericExec<TPgDirectFunc<&interval_ge>, true, true, TArgs_interval_ge_Policy>; }
-struct TArgs_interval_gt_Policy {
+TExecFunc arrow_inet_send() { return TGenericExec<TPgDirectFunc<&inet_send>, true, false, TArgs_inet_send_Policy>({}); }
+struct TArgs_inet_server_addr_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_interval_gt() { return &GenericExec<TPgDirectFunc<&interval_gt>, true, true, TArgs_interval_gt_Policy>; }
-struct TArgs_interval_hash_Policy {
+TExecFunc arrow_inet_server_addr() { return TGenericExec<TPgDirectFunc<&inet_server_addr>, false, false, TArgs_inet_server_addr_Policy>({}); }
+struct TArgs_inet_server_port_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_interval_hash() { return &GenericExec<TPgDirectFunc<&interval_hash>, true, true, TArgs_interval_hash_Policy>; }
-struct TArgs_interval_hash_extended_Policy {
+TExecFunc arrow_inet_server_port() { return TGenericExec<TPgDirectFunc<&inet_server_port>, false, true, TArgs_inet_server_port_Policy>({}); }
+struct TArgs_inet_set_masklen_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_interval_hash_extended() { return &GenericExec<TPgDirectFunc<&interval_hash_extended>, true, true, TArgs_interval_hash_extended_Policy>; }
-struct TArgs_interval_in_Policy {
+TExecFunc arrow_inet_set_masklen() { return TGenericExec<TPgDirectFunc<&inet_set_masklen>, true, false, TArgs_inet_set_masklen_Policy>({}); }
+struct TArgs_inet_to_cidr_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_interval_in() { return &GenericExec<TPgDirectFunc<&interval_in>, true, false, TArgs_interval_in_Policy>; }
-struct TArgs_interval_justify_days_Policy {
+TExecFunc arrow_inet_to_cidr() { return TGenericExec<TPgDirectFunc<&inet_to_cidr>, true, false, TArgs_inet_to_cidr_Policy>({}); }
+struct TArgs_inetand_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_interval_justify_days() { return &GenericExec<TPgDirectFunc<&interval_justify_days>, true, false, TArgs_interval_justify_days_Policy>; }
-struct TArgs_interval_justify_hours_Policy {
+TExecFunc arrow_inetand() { return TGenericExec<TPgDirectFunc<&inetand>, true, false, TArgs_inetand_Policy>({}); }
+struct TArgs_inetmi_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_interval_justify_hours() { return &GenericExec<TPgDirectFunc<&interval_justify_hours>, true, false, TArgs_interval_justify_hours_Policy>; }
-struct TArgs_interval_justify_interval_Policy {
+TExecFunc arrow_inetmi() { return TGenericExec<TPgDirectFunc<&inetmi>, true, true, TArgs_inetmi_Policy>({}); }
+struct TArgs_inetmi_int8_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_interval_justify_interval() { return &GenericExec<TPgDirectFunc<&interval_justify_interval>, true, false, TArgs_interval_justify_interval_Policy>; }
-struct TArgs_interval_larger_Policy {
+TExecFunc arrow_inetmi_int8() { return TGenericExec<TPgDirectFunc<&inetmi_int8>, true, false, TArgs_inetmi_int8_Policy>({}); }
+struct TArgs_inetnot_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_interval_larger() { return &GenericExec<TPgDirectFunc<&interval_larger>, true, false, TArgs_interval_larger_Policy>; }
-struct TArgs_interval_le_Policy {
+TExecFunc arrow_inetnot() { return TGenericExec<TPgDirectFunc<&inetnot>, true, false, TArgs_inetnot_Policy>({}); }
+struct TArgs_inetor_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_interval_le() { return &GenericExec<TPgDirectFunc<&interval_le>, true, true, TArgs_interval_le_Policy>; }
-struct TArgs_interval_lt_Policy {
+TExecFunc arrow_inetor() { return TGenericExec<TPgDirectFunc<&inetor>, true, false, TArgs_inetor_Policy>({}); }
+struct TArgs_inetpl_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_interval_lt() { return &GenericExec<TPgDirectFunc<&interval_lt>, true, true, TArgs_interval_lt_Policy>; }
-struct TArgs_interval_mi_Policy {
+TExecFunc arrow_inetpl() { return TGenericExec<TPgDirectFunc<&inetpl>, true, false, TArgs_inetpl_Policy>({}); }
+struct TArgs_initcap_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_interval_mi() { return &GenericExec<TPgDirectFunc<&interval_mi>, true, false, TArgs_interval_mi_Policy>; }
-struct TArgs_interval_mul_Policy {
+TExecFunc arrow_initcap() { return TGenericExec<TPgDirectFunc<&initcap>, true, false, TArgs_initcap_Policy>({}); }
+struct TArgs_int4range_canonical_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_interval_mul() { return &GenericExec<TPgDirectFunc<&interval_mul>, true, false, TArgs_interval_mul_Policy>; }
-struct TArgs_interval_ne_Policy {
+TExecFunc arrow_int4range_canonical() { return TGenericExec<TPgDirectFunc<&int4range_canonical>, true, false, TArgs_int4range_canonical_Policy>({}); }
+struct TArgs_int4range_subdiff_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_interval_ne() { return &GenericExec<TPgDirectFunc<&interval_ne>, true, true, TArgs_interval_ne_Policy>; }
-struct TArgs_interval_out_Policy {
+TExecFunc arrow_int4range_subdiff() { return TGenericExec<TPgDirectFunc<&int4range_subdiff>, true, true, TArgs_int4range_subdiff_Policy>({}); }
+struct TArgs_int8range_canonical_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_interval_out() { return &GenericExec<TPgDirectFunc<&interval_out>, true, false, TArgs_interval_out_Policy>; }
-struct TArgs_interval_part_Policy {
+TExecFunc arrow_int8range_canonical() { return TGenericExec<TPgDirectFunc<&int8range_canonical>, true, false, TArgs_int8range_canonical_Policy>({}); }
+struct TArgs_int8range_subdiff_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_interval_part() { return &GenericExec<TPgDirectFunc<&interval_part>, true, true, TArgs_interval_part_Policy>; }
-struct TArgs_interval_pl_Policy {
+TExecFunc arrow_int8range_subdiff() { return TGenericExec<TPgDirectFunc<&int8range_subdiff>, true, true, TArgs_int8range_subdiff_Policy>({}); }
+struct TArgs_json_agg_finalfn_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_interval_pl() { return &GenericExec<TPgDirectFunc<&interval_pl>, true, false, TArgs_interval_pl_Policy>; }
-struct TArgs_interval_recv_Policy {
+TExecFunc arrow_json_agg_finalfn() { return TGenericExec<TPgDirectFunc<&json_agg_finalfn>, false, false, TArgs_json_agg_finalfn_Policy>({}); }
+struct TArgs_json_agg_transfn_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_interval_recv() { return &GenericExec<TPgDirectFunc<&interval_recv>, true, false, TArgs_interval_recv_Policy>; }
-struct TArgs_interval_scale_Policy {
+TExecFunc arrow_json_agg_transfn() { return TGenericExec<TPgDirectFunc<&json_agg_transfn>, false, true, TArgs_json_agg_transfn_Policy>({}); }
+struct TArgs_json_array_element_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_interval_scale() { return &GenericExec<TPgDirectFunc<&interval_scale>, true, false, TArgs_interval_scale_Policy>; }
-struct TArgs_interval_send_Policy {
+TExecFunc arrow_json_array_element() { return TGenericExec<TPgDirectFunc<&json_array_element>, true, false, TArgs_json_array_element_Policy>({}); }
+struct TArgs_json_array_element_text_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_interval_send() { return &GenericExec<TPgDirectFunc<&interval_send>, true, false, TArgs_interval_send_Policy>; }
-struct TArgs_interval_smaller_Policy {
+TExecFunc arrow_json_array_element_text() { return TGenericExec<TPgDirectFunc<&json_array_element_text>, true, false, TArgs_json_array_element_text_Policy>({}); }
+struct TArgs_json_array_length_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_interval_smaller() { return &GenericExec<TPgDirectFunc<&interval_smaller>, true, false, TArgs_interval_smaller_Policy>; }
-struct TArgs_interval_support_Policy {
+TExecFunc arrow_json_array_length() { return TGenericExec<TPgDirectFunc<&json_array_length>, true, true, TArgs_json_array_length_Policy>({}); }
+struct TArgs_json_build_array_noargs_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_interval_support() { return &GenericExec<TPgDirectFunc<&interval_support>, true, true, TArgs_interval_support_Policy>; }
-struct TArgs_interval_trunc_Policy {
+TExecFunc arrow_json_build_array_noargs() { return TGenericExec<TPgDirectFunc<&json_build_array_noargs>, false, false, TArgs_json_build_array_noargs_Policy>({}); }
+struct TArgs_json_build_object_noargs_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_interval_trunc() { return &GenericExec<TPgDirectFunc<&interval_trunc>, true, false, TArgs_interval_trunc_Policy>; }
-struct TArgs_interval_um_Policy {
+TExecFunc arrow_json_build_object_noargs() { return TGenericExec<TPgDirectFunc<&json_build_object_noargs>, false, false, TArgs_json_build_object_noargs_Policy>({}); }
+struct TArgs_json_in_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_interval_um() { return &GenericExec<TPgDirectFunc<&interval_um>, true, false, TArgs_interval_um_Policy>; }
-struct TArgs_intervaltypmodin_Policy {
+TExecFunc arrow_json_in() { return TGenericExec<TPgDirectFunc<&json_in>, true, false, TArgs_json_in_Policy>({}); }
+struct TArgs_json_object_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_intervaltypmodin() { return &GenericExec<TPgDirectFunc<&intervaltypmodin>, true, true, TArgs_intervaltypmodin_Policy>; }
-struct TArgs_intervaltypmodout_Policy {
+TExecFunc arrow_json_object() { return TGenericExec<TPgDirectFunc<&json_object>, true, false, TArgs_json_object_Policy>({}); }
+struct TArgs_json_object_agg_finalfn_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_intervaltypmodout() { return &GenericExec<TPgDirectFunc<&intervaltypmodout>, true, false, TArgs_intervaltypmodout_Policy>; }
-struct TArgs_json_string_to_tsvector_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_json_string_to_tsvector() { return &GenericExec<TPgDirectFunc<&json_string_to_tsvector>, true, false, TArgs_json_string_to_tsvector_Policy>; }
-struct TArgs_json_string_to_tsvector_byid_Policy {
+TExecFunc arrow_json_object_agg_finalfn() { return TGenericExec<TPgDirectFunc<&json_object_agg_finalfn>, false, false, TArgs_json_object_agg_finalfn_Policy>({}); }
+struct TArgs_json_object_agg_transfn_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_json_string_to_tsvector_byid() { return &GenericExec<TPgDirectFunc<&json_string_to_tsvector_byid>, true, false, TArgs_json_string_to_tsvector_byid_Policy>; }
-struct TArgs_json_to_tsvector_Policy {
+TExecFunc arrow_json_object_agg_transfn() { return TGenericExec<TPgDirectFunc<&json_object_agg_transfn>, false, true, TArgs_json_object_agg_transfn_Policy>({}); }
+struct TArgs_json_object_field_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_json_to_tsvector() { return &GenericExec<TPgDirectFunc<&json_to_tsvector>, true, false, TArgs_json_to_tsvector_Policy>; }
-struct TArgs_json_to_tsvector_byid_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
-};
-TExecFunc arrow_json_to_tsvector_byid() { return &GenericExec<TPgDirectFunc<&json_to_tsvector_byid>, true, false, TArgs_json_to_tsvector_byid_Policy>; }
-struct TArgs_jsonb_path_exists_Policy {
+TExecFunc arrow_json_object_field() { return TGenericExec<TPgDirectFunc<&json_object_field>, true, false, TArgs_json_object_field_Policy>({}); }
+struct TArgs_json_object_field_text_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_jsonb_path_exists() { return &GenericExec<TPgDirectFunc<&jsonb_path_exists>, true, true, TArgs_jsonb_path_exists_Policy>; }
-struct TArgs_jsonb_path_exists_opr_Policy {
+TExecFunc arrow_json_object_field_text() { return TGenericExec<TPgDirectFunc<&json_object_field_text>, true, false, TArgs_json_object_field_text_Policy>({}); }
+struct TArgs_json_object_two_arg_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_jsonb_path_exists_opr() { return &GenericExec<TPgDirectFunc<&jsonb_path_exists_opr>, true, true, TArgs_jsonb_path_exists_opr_Policy>; }
-struct TArgs_jsonb_path_exists_tz_Policy {
+TExecFunc arrow_json_object_two_arg() { return TGenericExec<TPgDirectFunc<&json_object_two_arg>, true, false, TArgs_json_object_two_arg_Policy>({}); }
+struct TArgs_json_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_jsonb_path_exists_tz() { return &GenericExec<TPgDirectFunc<&jsonb_path_exists_tz>, true, true, TArgs_jsonb_path_exists_tz_Policy>; }
-struct TArgs_jsonb_path_match_Policy {
+TExecFunc arrow_json_out() { return TGenericExec<TPgDirectFunc<&json_out>, true, false, TArgs_json_out_Policy>({}); }
+struct TArgs_json_populate_record_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,false,true};
 };
-TExecFunc arrow_jsonb_path_match() { return &GenericExec<TPgDirectFunc<&jsonb_path_match>, true, true, TArgs_jsonb_path_match_Policy>; }
-struct TArgs_jsonb_path_match_opr_Policy {
+TExecFunc arrow_json_populate_record() { return TGenericExec<TPgDirectFunc<&json_populate_record>, false, true, TArgs_json_populate_record_Policy>({}); }
+struct TArgs_json_recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_jsonb_path_match_opr() { return &GenericExec<TPgDirectFunc<&jsonb_path_match_opr>, true, true, TArgs_jsonb_path_match_opr_Policy>; }
-struct TArgs_jsonb_path_match_tz_Policy {
+TExecFunc arrow_json_recv() { return TGenericExec<TPgDirectFunc<&json_recv>, true, false, TArgs_json_recv_Policy>({}); }
+struct TArgs_json_send_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_jsonb_path_match_tz() { return &GenericExec<TPgDirectFunc<&jsonb_path_match_tz>, true, true, TArgs_jsonb_path_match_tz_Policy>; }
-struct TArgs_jsonb_path_query_array_Policy {
+TExecFunc arrow_json_send() { return TGenericExec<TPgDirectFunc<&json_send>, true, false, TArgs_json_send_Policy>({}); }
+struct TArgs_json_strip_nulls_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_jsonb_path_query_array() { return &GenericExec<TPgDirectFunc<&jsonb_path_query_array>, true, false, TArgs_jsonb_path_query_array_Policy>; }
-struct TArgs_jsonb_path_query_array_tz_Policy {
+TExecFunc arrow_json_strip_nulls() { return TGenericExec<TPgDirectFunc<&json_strip_nulls>, true, false, TArgs_json_strip_nulls_Policy>({}); }
+struct TArgs_json_to_record_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_jsonb_path_query_array_tz() { return &GenericExec<TPgDirectFunc<&jsonb_path_query_array_tz>, true, false, TArgs_jsonb_path_query_array_tz_Policy>; }
-struct TArgs_jsonb_path_query_first_Policy {
+TExecFunc arrow_json_to_record() { return TGenericExec<TPgDirectFunc<&json_to_record>, true, false, TArgs_json_to_record_Policy>({}); }
+struct TArgs_json_typeof_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_jsonb_path_query_first() { return &GenericExec<TPgDirectFunc<&jsonb_path_query_first>, true, false, TArgs_jsonb_path_query_first_Policy>; }
-struct TArgs_jsonb_path_query_first_tz_Policy {
+TExecFunc arrow_json_typeof() { return TGenericExec<TPgDirectFunc<&json_typeof>, true, false, TArgs_json_typeof_Policy>({}); }
+struct TArgs_jsonb_agg_finalfn_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_jsonb_path_query_first_tz() { return &GenericExec<TPgDirectFunc<&jsonb_path_query_first_tz>, true, false, TArgs_jsonb_path_query_first_tz_Policy>; }
-struct TArgs_jsonb_string_to_tsvector_Policy {
+TExecFunc arrow_jsonb_agg_finalfn() { return TGenericExec<TPgDirectFunc<&jsonb_agg_finalfn>, false, false, TArgs_jsonb_agg_finalfn_Policy>({}); }
+struct TArgs_jsonb_agg_transfn_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_jsonb_string_to_tsvector() { return &GenericExec<TPgDirectFunc<&jsonb_string_to_tsvector>, true, false, TArgs_jsonb_string_to_tsvector_Policy>; }
-struct TArgs_jsonb_string_to_tsvector_byid_Policy {
+TExecFunc arrow_jsonb_agg_transfn() { return TGenericExec<TPgDirectFunc<&jsonb_agg_transfn>, false, true, TArgs_jsonb_agg_transfn_Policy>({}); }
+struct TArgs_jsonb_array_element_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_jsonb_string_to_tsvector_byid() { return &GenericExec<TPgDirectFunc<&jsonb_string_to_tsvector_byid>, true, false, TArgs_jsonb_string_to_tsvector_byid_Policy>; }
-struct TArgs_jsonb_to_tsvector_Policy {
+TExecFunc arrow_jsonb_array_element() { return TGenericExec<TPgDirectFunc<&jsonb_array_element>, true, false, TArgs_jsonb_array_element_Policy>({}); }
+struct TArgs_jsonb_array_element_text_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_jsonb_to_tsvector() { return &GenericExec<TPgDirectFunc<&jsonb_to_tsvector>, true, false, TArgs_jsonb_to_tsvector_Policy>; }
-struct TArgs_jsonb_to_tsvector_byid_Policy {
+TExecFunc arrow_jsonb_array_element_text() { return TGenericExec<TPgDirectFunc<&jsonb_array_element_text>, true, false, TArgs_jsonb_array_element_text_Policy>({}); }
+struct TArgs_jsonb_array_length_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_jsonb_to_tsvector_byid() { return &GenericExec<TPgDirectFunc<&jsonb_to_tsvector_byid>, true, false, TArgs_jsonb_to_tsvector_byid_Policy>; }
-struct TArgs_language_handler_in_Policy {
+TExecFunc arrow_jsonb_array_length() { return TGenericExec<TPgDirectFunc<&jsonb_array_length>, true, true, TArgs_jsonb_array_length_Policy>({}); }
+struct TArgs_jsonb_bool_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_language_handler_in() { return &GenericExec<TPgDirectFunc<&language_handler_in>, false, true, TArgs_language_handler_in_Policy>; }
-struct TArgs_language_handler_out_Policy {
+TExecFunc arrow_jsonb_bool() { return TGenericExec<TPgDirectFunc<&jsonb_bool>, true, true, TArgs_jsonb_bool_Policy>({}); }
+struct TArgs_jsonb_build_array_noargs_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_language_handler_out() { return &GenericExec<TPgDirectFunc<&language_handler_out>, true, false, TArgs_language_handler_out_Policy>; }
-struct TArgs_likejoinsel_Policy {
+TExecFunc arrow_jsonb_build_array_noargs() { return TGenericExec<TPgDirectFunc<&jsonb_build_array_noargs>, false, false, TArgs_jsonb_build_array_noargs_Policy>({}); }
+struct TArgs_jsonb_build_object_noargs_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_likejoinsel() { return &GenericExec<TPgDirectFunc<&likejoinsel>, true, true, TArgs_likejoinsel_Policy>; }
-struct TArgs_likesel_Policy {
+TExecFunc arrow_jsonb_build_object_noargs() { return TGenericExec<TPgDirectFunc<&jsonb_build_object_noargs>, false, false, TArgs_jsonb_build_object_noargs_Policy>({}); }
+struct TArgs_jsonb_concat_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_likesel() { return &GenericExec<TPgDirectFunc<&likesel>, true, true, TArgs_likesel_Policy>; }
-struct TArgs_macaddr_and_Policy {
+TExecFunc arrow_jsonb_concat() { return TGenericExec<TPgDirectFunc<&jsonb_concat>, true, false, TArgs_jsonb_concat_Policy>({}); }
+struct TArgs_jsonb_delete_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_macaddr_and() { return &GenericExec<TPgDirectFunc<&macaddr_and>, true, false, TArgs_macaddr_and_Policy>; }
-struct TArgs_macaddr_cmp_Policy {
+TExecFunc arrow_jsonb_delete() { return TGenericExec<TPgDirectFunc<&jsonb_delete>, true, false, TArgs_jsonb_delete_Policy>({}); }
+struct TArgs_jsonb_delete_idx_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_macaddr_cmp() { return &GenericExec<TPgDirectFunc<&macaddr_cmp>, true, true, TArgs_macaddr_cmp_Policy>; }
-struct TArgs_macaddr_eq_Policy {
+TExecFunc arrow_jsonb_delete_idx() { return TGenericExec<TPgDirectFunc<&jsonb_delete_idx>, true, false, TArgs_jsonb_delete_idx_Policy>({}); }
+struct TArgs_jsonb_delete_path_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_macaddr_eq() { return &GenericExec<TPgDirectFunc<&macaddr_eq>, true, true, TArgs_macaddr_eq_Policy>; }
-struct TArgs_macaddr_ge_Policy {
+TExecFunc arrow_jsonb_delete_path() { return TGenericExec<TPgDirectFunc<&jsonb_delete_path>, true, false, TArgs_jsonb_delete_path_Policy>({}); }
+struct TArgs_jsonb_float4_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_macaddr_ge() { return &GenericExec<TPgDirectFunc<&macaddr_ge>, true, true, TArgs_macaddr_ge_Policy>; }
-struct TArgs_macaddr_gt_Policy {
+TExecFunc arrow_jsonb_float4() { return TGenericExec<TPgDirectFunc<&jsonb_float4>, true, true, TArgs_jsonb_float4_Policy>({}); }
+struct TArgs_jsonb_float8_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_macaddr_gt() { return &GenericExec<TPgDirectFunc<&macaddr_gt>, true, true, TArgs_macaddr_gt_Policy>; }
-struct TArgs_macaddr_in_Policy {
+TExecFunc arrow_jsonb_float8() { return TGenericExec<TPgDirectFunc<&jsonb_float8>, true, true, TArgs_jsonb_float8_Policy>({}); }
+struct TArgs_jsonb_in_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_macaddr_in() { return &GenericExec<TPgDirectFunc<&macaddr_in>, true, false, TArgs_macaddr_in_Policy>; }
-struct TArgs_macaddr_le_Policy {
+TExecFunc arrow_jsonb_in() { return TGenericExec<TPgDirectFunc<&jsonb_in>, true, false, TArgs_jsonb_in_Policy>({}); }
+struct TArgs_jsonb_insert_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,true};
 };
-TExecFunc arrow_macaddr_le() { return &GenericExec<TPgDirectFunc<&macaddr_le>, true, true, TArgs_macaddr_le_Policy>; }
-struct TArgs_macaddr_lt_Policy {
+TExecFunc arrow_jsonb_insert() { return TGenericExec<TPgDirectFunc<&jsonb_insert>, true, false, TArgs_jsonb_insert_Policy>({}); }
+struct TArgs_jsonb_int2_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_macaddr_lt() { return &GenericExec<TPgDirectFunc<&macaddr_lt>, true, true, TArgs_macaddr_lt_Policy>; }
-struct TArgs_macaddr_ne_Policy {
+TExecFunc arrow_jsonb_int2() { return TGenericExec<TPgDirectFunc<&jsonb_int2>, true, true, TArgs_jsonb_int2_Policy>({}); }
+struct TArgs_jsonb_int4_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_macaddr_ne() { return &GenericExec<TPgDirectFunc<&macaddr_ne>, true, true, TArgs_macaddr_ne_Policy>; }
-struct TArgs_macaddr_not_Policy {
+TExecFunc arrow_jsonb_int4() { return TGenericExec<TPgDirectFunc<&jsonb_int4>, true, true, TArgs_jsonb_int4_Policy>({}); }
+struct TArgs_jsonb_int8_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_macaddr_not() { return &GenericExec<TPgDirectFunc<&macaddr_not>, true, false, TArgs_macaddr_not_Policy>; }
-struct TArgs_macaddr_or_Policy {
+TExecFunc arrow_jsonb_int8() { return TGenericExec<TPgDirectFunc<&jsonb_int8>, true, true, TArgs_jsonb_int8_Policy>({}); }
+struct TArgs_jsonb_numeric_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_macaddr_or() { return &GenericExec<TPgDirectFunc<&macaddr_or>, true, false, TArgs_macaddr_or_Policy>; }
-struct TArgs_macaddr_out_Policy {
+TExecFunc arrow_jsonb_numeric() { return TGenericExec<TPgDirectFunc<&jsonb_numeric>, true, false, TArgs_jsonb_numeric_Policy>({}); }
+struct TArgs_jsonb_object_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_macaddr_out() { return &GenericExec<TPgDirectFunc<&macaddr_out>, true, false, TArgs_macaddr_out_Policy>; }
-struct TArgs_macaddr_recv_Policy {
+TExecFunc arrow_jsonb_object() { return TGenericExec<TPgDirectFunc<&jsonb_object>, true, false, TArgs_jsonb_object_Policy>({}); }
+struct TArgs_jsonb_object_agg_finalfn_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_macaddr_recv() { return &GenericExec<TPgDirectFunc<&macaddr_recv>, true, false, TArgs_macaddr_recv_Policy>; }
-struct TArgs_macaddr_send_Policy {
+TExecFunc arrow_jsonb_object_agg_finalfn() { return TGenericExec<TPgDirectFunc<&jsonb_object_agg_finalfn>, false, false, TArgs_jsonb_object_agg_finalfn_Policy>({}); }
+struct TArgs_jsonb_object_agg_transfn_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_macaddr_send() { return &GenericExec<TPgDirectFunc<&macaddr_send>, true, false, TArgs_macaddr_send_Policy>; }
-struct TArgs_macaddr_sortsupport_Policy {
+TExecFunc arrow_jsonb_object_agg_transfn() { return TGenericExec<TPgDirectFunc<&jsonb_object_agg_transfn>, false, true, TArgs_jsonb_object_agg_transfn_Policy>({}); }
+struct TArgs_jsonb_object_field_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_macaddr_sortsupport() { return &GenericExec<TPgDirectFunc<&macaddr_sortsupport>, true, true, TArgs_macaddr_sortsupport_Policy>; }
-struct TArgs_macaddr_trunc_Policy {
+TExecFunc arrow_jsonb_object_field() { return TGenericExec<TPgDirectFunc<&jsonb_object_field>, true, false, TArgs_jsonb_object_field_Policy>({}); }
+struct TArgs_jsonb_object_field_text_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_macaddr_trunc() { return &GenericExec<TPgDirectFunc<&macaddr_trunc>, true, false, TArgs_macaddr_trunc_Policy>; }
-struct TArgs_make_interval_Policy {
+TExecFunc arrow_jsonb_object_field_text() { return TGenericExec<TPgDirectFunc<&jsonb_object_field_text>, true, false, TArgs_jsonb_object_field_text_Policy>({}); }
+struct TArgs_jsonb_object_two_arg_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 7> IsFixedArg = {true,true,true,true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_make_interval() { return &GenericExec<TPgDirectFunc<&make_interval>, true, false, TArgs_make_interval_Policy>; }
-struct TArgs_make_timestamp_Policy {
+TExecFunc arrow_jsonb_object_two_arg() { return TGenericExec<TPgDirectFunc<&jsonb_object_two_arg>, true, false, TArgs_jsonb_object_two_arg_Policy>({}); }
+struct TArgs_jsonb_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 6> IsFixedArg = {true,true,true,true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_make_timestamp() { return &GenericExec<TPgDirectFunc<&make_timestamp>, true, true, TArgs_make_timestamp_Policy>; }
-struct TArgs_make_timestamptz_Policy {
+TExecFunc arrow_jsonb_out() { return TGenericExec<TPgDirectFunc<&jsonb_out>, true, false, TArgs_jsonb_out_Policy>({}); }
+struct TArgs_jsonb_populate_record_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 6> IsFixedArg = {true,true,true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_make_timestamptz() { return &GenericExec<TPgDirectFunc<&make_timestamptz>, true, true, TArgs_make_timestamptz_Policy>; }
-struct TArgs_make_timestamptz_at_timezone_Policy {
+TExecFunc arrow_jsonb_populate_record() { return TGenericExec<TPgDirectFunc<&jsonb_populate_record>, false, true, TArgs_jsonb_populate_record_Policy>({}); }
+struct TArgs_jsonb_pretty_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 7> IsFixedArg = {true,true,true,true,true,true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_make_timestamptz_at_timezone() { return &GenericExec<TPgDirectFunc<&make_timestamptz_at_timezone>, true, true, TArgs_make_timestamptz_at_timezone_Policy>; }
-struct TArgs_mode_final_Policy {
+TExecFunc arrow_jsonb_pretty() { return TGenericExec<TPgDirectFunc<&jsonb_pretty>, true, false, TArgs_jsonb_pretty_Policy>({}); }
+struct TArgs_jsonb_recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_mode_final() { return &GenericExec<TPgDirectFunc<&mode_final>, false, true, TArgs_mode_final_Policy>; }
-struct TArgs_mul_d_interval_Policy {
+TExecFunc arrow_jsonb_recv() { return TGenericExec<TPgDirectFunc<&jsonb_recv>, true, false, TArgs_jsonb_recv_Policy>({}); }
+struct TArgs_jsonb_send_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_mul_d_interval() { return &GenericExec<TPgDirectFunc<&mul_d_interval>, true, false, TArgs_mul_d_interval_Policy>; }
-struct TArgs_multirangesel_Policy {
+TExecFunc arrow_jsonb_send() { return TGenericExec<TPgDirectFunc<&jsonb_send>, true, false, TArgs_jsonb_send_Policy>({}); }
+struct TArgs_jsonb_set_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,true};
 };
-TExecFunc arrow_multirangesel() { return &GenericExec<TPgDirectFunc<&multirangesel>, true, true, TArgs_multirangesel_Policy>; }
-struct TArgs_networkjoinsel_Policy {
+TExecFunc arrow_jsonb_set() { return TGenericExec<TPgDirectFunc<&jsonb_set>, true, false, TArgs_jsonb_set_Policy>({}); }
+struct TArgs_jsonb_set_lax_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+    static constexpr std::array<bool, 5> IsFixedArg = {false,false,false,true,false};
 };
-TExecFunc arrow_networkjoinsel() { return &GenericExec<TPgDirectFunc<&networkjoinsel>, true, true, TArgs_networkjoinsel_Policy>; }
-struct TArgs_networksel_Policy {
+TExecFunc arrow_jsonb_set_lax() { return TGenericExec<TPgDirectFunc<&jsonb_set_lax>, false, false, TArgs_jsonb_set_lax_Policy>({}); }
+struct TArgs_jsonb_strip_nulls_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_networksel() { return &GenericExec<TPgDirectFunc<&networksel>, true, true, TArgs_networksel_Policy>; }
-struct TArgs_nlikejoinsel_Policy {
+TExecFunc arrow_jsonb_strip_nulls() { return TGenericExec<TPgDirectFunc<&jsonb_strip_nulls>, true, false, TArgs_jsonb_strip_nulls_Policy>({}); }
+struct TArgs_jsonb_subscript_handler_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_nlikejoinsel() { return &GenericExec<TPgDirectFunc<&nlikejoinsel>, true, true, TArgs_nlikejoinsel_Policy>; }
-struct TArgs_nlikesel_Policy {
+TExecFunc arrow_jsonb_subscript_handler() { return TGenericExec<TPgDirectFunc<&jsonb_subscript_handler>, true, true, TArgs_jsonb_subscript_handler_Policy>({}); }
+struct TArgs_jsonb_to_record_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_nlikesel() { return &GenericExec<TPgDirectFunc<&nlikesel>, true, true, TArgs_nlikesel_Policy>; }
-struct TArgs_now_Policy {
+TExecFunc arrow_jsonb_to_record() { return TGenericExec<TPgDirectFunc<&jsonb_to_record>, true, false, TArgs_jsonb_to_record_Policy>({}); }
+struct TArgs_jsonb_typeof_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_now() { return &GenericExec<TPgDirectFunc<&now>, true, true, TArgs_now_Policy>; }
-struct TArgs_numeric_Policy {
+TExecFunc arrow_jsonb_typeof() { return TGenericExec<TPgDirectFunc<&jsonb_typeof>, true, false, TArgs_jsonb_typeof_Policy>({}); }
+struct TArgs_jsonpath_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_numeric() { return &GenericExec<TPgDirectFunc<&numeric>, true, false, TArgs_numeric_Policy>; }
-struct TArgs_numeric_abs_Policy {
+TExecFunc arrow_jsonpath_in() { return TGenericExec<TPgDirectFunc<&jsonpath_in>, true, false, TArgs_jsonpath_in_Policy>({}); }
+struct TArgs_jsonpath_out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_numeric_abs() { return &GenericExec<TPgDirectFunc<&numeric_abs>, true, false, TArgs_numeric_abs_Policy>; }
-struct TArgs_numeric_accum_Policy {
+TExecFunc arrow_jsonpath_out() { return TGenericExec<TPgDirectFunc<&jsonpath_out>, true, false, TArgs_jsonpath_out_Policy>({}); }
+struct TArgs_jsonpath_recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_numeric_accum() { return &GenericExec<TPgDirectFunc<&numeric_accum>, false, true, TArgs_numeric_accum_Policy>; }
-struct TArgs_numeric_accum_inv_Policy {
+TExecFunc arrow_jsonpath_recv() { return TGenericExec<TPgDirectFunc<&jsonpath_recv>, true, false, TArgs_jsonpath_recv_Policy>({}); }
+struct TArgs_jsonpath_send_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_numeric_accum_inv() { return &GenericExec<TPgDirectFunc<&numeric_accum_inv>, false, true, TArgs_numeric_accum_inv_Policy>; }
-struct TArgs_numeric_add_Policy {
+TExecFunc arrow_jsonpath_send() { return TGenericExec<TPgDirectFunc<&jsonpath_send>, true, false, TArgs_jsonpath_send_Policy>({}); }
+struct TArgs_length_in_encoding_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_add() { return &GenericExec<TPgDirectFunc<&numeric_add>, true, false, TArgs_numeric_add_Policy>; }
-struct TArgs_numeric_avg_Policy {
+TExecFunc arrow_length_in_encoding() { return TGenericExec<TPgDirectFunc<&length_in_encoding>, true, true, TArgs_length_in_encoding_Policy>({}); }
+struct TArgs_like_escape_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_avg() { return &GenericExec<TPgDirectFunc<&numeric_avg>, false, false, TArgs_numeric_avg_Policy>; }
-struct TArgs_numeric_avg_accum_Policy {
+TExecFunc arrow_like_escape() { return TGenericExec<TPgDirectFunc<&like_escape>, true, false, TArgs_like_escape_Policy>({}); }
+struct TArgs_like_escape_bytea_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_avg_accum() { return &GenericExec<TPgDirectFunc<&numeric_avg_accum>, false, true, TArgs_numeric_avg_accum_Policy>; }
-struct TArgs_numeric_avg_combine_Policy {
+TExecFunc arrow_like_escape_bytea() { return TGenericExec<TPgDirectFunc<&like_escape_bytea>, true, false, TArgs_like_escape_bytea_Policy>({}); }
+struct TArgs_lower_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_numeric_avg_combine() { return &GenericExec<TPgDirectFunc<&numeric_avg_combine>, false, true, TArgs_numeric_avg_combine_Policy>; }
-struct TArgs_numeric_avg_deserialize_Policy {
+TExecFunc arrow_lower() { return TGenericExec<TPgDirectFunc<&lower>, true, false, TArgs_lower_Policy>({}); }
+struct TArgs_lpad_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
 };
-TExecFunc arrow_numeric_avg_deserialize() { return &GenericExec<TPgDirectFunc<&numeric_avg_deserialize>, true, true, TArgs_numeric_avg_deserialize_Policy>; }
-struct TArgs_numeric_avg_serialize_Policy {
+TExecFunc arrow_lpad() { return TGenericExec<TPgDirectFunc<&lpad>, true, false, TArgs_lpad_Policy>({}); }
+struct TArgs_ltrim_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_avg_serialize() { return &GenericExec<TPgDirectFunc<&numeric_avg_serialize>, true, false, TArgs_numeric_avg_serialize_Policy>; }
-struct TArgs_numeric_ceil_Policy {
+TExecFunc arrow_ltrim() { return TGenericExec<TPgDirectFunc<&ltrim>, true, false, TArgs_ltrim_Policy>({}); }
+struct TArgs_ltrim1_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_numeric_ceil() { return &GenericExec<TPgDirectFunc<&numeric_ceil>, true, false, TArgs_numeric_ceil_Policy>; }
-struct TArgs_numeric_cmp_Policy {
+TExecFunc arrow_ltrim1() { return TGenericExec<TPgDirectFunc<&ltrim1>, true, false, TArgs_ltrim1_Policy>({}); }
+struct TArgs_macaddr8_and_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_cmp() { return &GenericExec<TPgDirectFunc<&numeric_cmp>, true, true, TArgs_numeric_cmp_Policy>; }
-struct TArgs_numeric_combine_Policy {
+TExecFunc arrow_macaddr8_and() { return TGenericExec<TPgDirectFunc<&macaddr8_and>, true, false, TArgs_macaddr8_and_Policy>({}); }
+struct TArgs_macaddr8_cmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
-};
-TExecFunc arrow_numeric_combine() { return &GenericExec<TPgDirectFunc<&numeric_combine>, false, true, TArgs_numeric_combine_Policy>; }
-struct TArgs_numeric_deserialize_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_deserialize() { return &GenericExec<TPgDirectFunc<&numeric_deserialize>, true, true, TArgs_numeric_deserialize_Policy>; }
-struct TArgs_numeric_div_Policy {
+TExecFunc arrow_macaddr8_cmp() { return TGenericExec<TPgDirectFunc<&macaddr8_cmp>, true, true, TArgs_macaddr8_cmp_Policy>({}); }
+struct TArgs_macaddr8_eq_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_div() { return &GenericExec<TPgDirectFunc<&numeric_div>, true, false, TArgs_numeric_div_Policy>; }
-struct TArgs_numeric_div_trunc_Policy {
+TExecFunc arrow_macaddr8_eq() { return TGenericExec<TPgDirectFunc<&macaddr8_eq>, true, true, TArgs_macaddr8_eq_Policy>({}); }
+struct TArgs_macaddr8_ge_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_div_trunc() { return &GenericExec<TPgDirectFunc<&numeric_div_trunc>, true, false, TArgs_numeric_div_trunc_Policy>; }
-struct TArgs_numeric_eq_Policy {
+TExecFunc arrow_macaddr8_ge() { return TGenericExec<TPgDirectFunc<&macaddr8_ge>, true, true, TArgs_macaddr8_ge_Policy>({}); }
+struct TArgs_macaddr8_gt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_eq() { return &GenericExec<TPgDirectFunc<&numeric_eq>, true, true, TArgs_numeric_eq_Policy>; }
-struct TArgs_numeric_exp_Policy {
+TExecFunc arrow_macaddr8_gt() { return TGenericExec<TPgDirectFunc<&macaddr8_gt>, true, true, TArgs_macaddr8_gt_Policy>({}); }
+struct TArgs_macaddr8_in_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_numeric_exp() { return &GenericExec<TPgDirectFunc<&numeric_exp>, true, false, TArgs_numeric_exp_Policy>; }
-struct TArgs_numeric_fac_Policy {
+TExecFunc arrow_macaddr8_in() { return TGenericExec<TPgDirectFunc<&macaddr8_in>, true, false, TArgs_macaddr8_in_Policy>({}); }
+struct TArgs_macaddr8_le_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_fac() { return &GenericExec<TPgDirectFunc<&numeric_fac>, true, false, TArgs_numeric_fac_Policy>; }
-struct TArgs_numeric_float4_Policy {
+TExecFunc arrow_macaddr8_le() { return TGenericExec<TPgDirectFunc<&macaddr8_le>, true, true, TArgs_macaddr8_le_Policy>({}); }
+struct TArgs_macaddr8_lt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_float4() { return &GenericExec<TPgDirectFunc<&numeric_float4>, true, true, TArgs_numeric_float4_Policy>; }
-struct TArgs_numeric_float8_Policy {
+TExecFunc arrow_macaddr8_lt() { return TGenericExec<TPgDirectFunc<&macaddr8_lt>, true, true, TArgs_macaddr8_lt_Policy>({}); }
+struct TArgs_macaddr8_ne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_float8() { return &GenericExec<TPgDirectFunc<&numeric_float8>, true, true, TArgs_numeric_float8_Policy>; }
-struct TArgs_numeric_floor_Policy {
+TExecFunc arrow_macaddr8_ne() { return TGenericExec<TPgDirectFunc<&macaddr8_ne>, true, true, TArgs_macaddr8_ne_Policy>({}); }
+struct TArgs_macaddr8_not_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_numeric_floor() { return &GenericExec<TPgDirectFunc<&numeric_floor>, true, false, TArgs_numeric_floor_Policy>; }
-struct TArgs_numeric_gcd_Policy {
+TExecFunc arrow_macaddr8_not() { return TGenericExec<TPgDirectFunc<&macaddr8_not>, true, false, TArgs_macaddr8_not_Policy>({}); }
+struct TArgs_macaddr8_or_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_gcd() { return &GenericExec<TPgDirectFunc<&numeric_gcd>, true, false, TArgs_numeric_gcd_Policy>; }
-struct TArgs_numeric_ge_Policy {
+TExecFunc arrow_macaddr8_or() { return TGenericExec<TPgDirectFunc<&macaddr8_or>, true, false, TArgs_macaddr8_or_Policy>({}); }
+struct TArgs_macaddr8_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_numeric_ge() { return &GenericExec<TPgDirectFunc<&numeric_ge>, true, true, TArgs_numeric_ge_Policy>; }
-struct TArgs_numeric_gt_Policy {
+TExecFunc arrow_macaddr8_out() { return TGenericExec<TPgDirectFunc<&macaddr8_out>, true, false, TArgs_macaddr8_out_Policy>({}); }
+struct TArgs_macaddr8_recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_numeric_gt() { return &GenericExec<TPgDirectFunc<&numeric_gt>, true, true, TArgs_numeric_gt_Policy>; }
-struct TArgs_numeric_in_Policy {
+TExecFunc arrow_macaddr8_recv() { return TGenericExec<TPgDirectFunc<&macaddr8_recv>, true, false, TArgs_macaddr8_recv_Policy>({}); }
+struct TArgs_macaddr8_send_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_numeric_in() { return &GenericExec<TPgDirectFunc<&numeric_in>, true, false, TArgs_numeric_in_Policy>; }
-struct TArgs_numeric_inc_Policy {
+TExecFunc arrow_macaddr8_send() { return TGenericExec<TPgDirectFunc<&macaddr8_send>, true, false, TArgs_macaddr8_send_Policy>({}); }
+struct TArgs_macaddr8_set7bit_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_numeric_inc() { return &GenericExec<TPgDirectFunc<&numeric_inc>, true, false, TArgs_numeric_inc_Policy>; }
-struct TArgs_numeric_int2_Policy {
+TExecFunc arrow_macaddr8_set7bit() { return TGenericExec<TPgDirectFunc<&macaddr8_set7bit>, true, false, TArgs_macaddr8_set7bit_Policy>({}); }
+struct TArgs_macaddr8_trunc_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_numeric_int2() { return &GenericExec<TPgDirectFunc<&numeric_int2>, true, true, TArgs_numeric_int2_Policy>; }
-struct TArgs_numeric_int4_Policy {
+TExecFunc arrow_macaddr8_trunc() { return TGenericExec<TPgDirectFunc<&macaddr8_trunc>, true, false, TArgs_macaddr8_trunc_Policy>({}); }
+struct TArgs_macaddr8tomacaddr_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_numeric_int4() { return &GenericExec<TPgDirectFunc<&numeric_int4>, true, true, TArgs_numeric_int4_Policy>; }
-struct TArgs_numeric_int8_Policy {
+TExecFunc arrow_macaddr8tomacaddr() { return TGenericExec<TPgDirectFunc<&macaddr8tomacaddr>, true, false, TArgs_macaddr8tomacaddr_Policy>({}); }
+struct TArgs_macaddrtomacaddr8_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_numeric_int8() { return &GenericExec<TPgDirectFunc<&numeric_int8>, true, true, TArgs_numeric_int8_Policy>; }
-struct TArgs_numeric_larger_Policy {
+TExecFunc arrow_macaddrtomacaddr8() { return TGenericExec<TPgDirectFunc<&macaddrtomacaddr8>, true, false, TArgs_macaddrtomacaddr8_Policy>({}); }
+struct TArgs_matchingjoinsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
 };
-TExecFunc arrow_numeric_larger() { return &GenericExec<TPgDirectFunc<&numeric_larger>, true, false, TArgs_numeric_larger_Policy>; }
-struct TArgs_numeric_lcm_Policy {
+TExecFunc arrow_matchingjoinsel() { return TGenericExec<TPgDirectFunc<&matchingjoinsel>, true, true, TArgs_matchingjoinsel_Policy>({}); }
+struct TArgs_matchingsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_numeric_lcm() { return &GenericExec<TPgDirectFunc<&numeric_lcm>, true, false, TArgs_numeric_lcm_Policy>; }
-struct TArgs_numeric_le_Policy {
+TExecFunc arrow_matchingsel() { return TGenericExec<TPgDirectFunc<&matchingsel>, true, true, TArgs_matchingsel_Policy>({}); }
+struct TArgs_nameiclike_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_le() { return &GenericExec<TPgDirectFunc<&numeric_le>, true, true, TArgs_numeric_le_Policy>; }
-struct TArgs_numeric_ln_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_numeric_ln() { return &GenericExec<TPgDirectFunc<&numeric_ln>, true, false, TArgs_numeric_ln_Policy>; }
-struct TArgs_numeric_log_Policy {
+TExecFunc arrow_nameiclike() { return TGenericExec<TPgDirectFunc<&nameiclike>, true, true, TArgs_nameiclike_Policy>({}); }
+struct TArgs_nameicnlike_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_log() { return &GenericExec<TPgDirectFunc<&numeric_log>, true, false, TArgs_numeric_log_Policy>; }
-struct TArgs_numeric_lt_Policy {
+TExecFunc arrow_nameicnlike() { return TGenericExec<TPgDirectFunc<&nameicnlike>, true, true, TArgs_nameicnlike_Policy>({}); }
+struct TArgs_nameicregexeq_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_lt() { return &GenericExec<TPgDirectFunc<&numeric_lt>, true, true, TArgs_numeric_lt_Policy>; }
-struct TArgs_numeric_min_scale_Policy {
+TExecFunc arrow_nameicregexeq() { return TGenericExec<TPgDirectFunc<&nameicregexeq>, true, true, TArgs_nameicregexeq_Policy>({}); }
+struct TArgs_nameicregexne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_min_scale() { return &GenericExec<TPgDirectFunc<&numeric_min_scale>, true, true, TArgs_numeric_min_scale_Policy>; }
-struct TArgs_numeric_mod_Policy {
+TExecFunc arrow_nameicregexne() { return TGenericExec<TPgDirectFunc<&nameicregexne>, true, true, TArgs_nameicregexne_Policy>({}); }
+struct TArgs_namelike_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_mod() { return &GenericExec<TPgDirectFunc<&numeric_mod>, true, false, TArgs_numeric_mod_Policy>; }
-struct TArgs_numeric_mul_Policy {
+TExecFunc arrow_namelike() { return TGenericExec<TPgDirectFunc<&namelike>, true, true, TArgs_namelike_Policy>({}); }
+struct TArgs_namenlike_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_mul() { return &GenericExec<TPgDirectFunc<&numeric_mul>, true, false, TArgs_numeric_mul_Policy>; }
-struct TArgs_numeric_ne_Policy {
+TExecFunc arrow_namenlike() { return TGenericExec<TPgDirectFunc<&namenlike>, true, true, TArgs_namenlike_Policy>({}); }
+struct TArgs_nameregexeq_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_ne() { return &GenericExec<TPgDirectFunc<&numeric_ne>, true, true, TArgs_numeric_ne_Policy>; }
-struct TArgs_numeric_out_Policy {
+TExecFunc arrow_nameregexeq() { return TGenericExec<TPgDirectFunc<&nameregexeq>, true, true, TArgs_nameregexeq_Policy>({}); }
+struct TArgs_nameregexne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_out() { return &GenericExec<TPgDirectFunc<&numeric_out>, true, false, TArgs_numeric_out_Policy>; }
-struct TArgs_numeric_pg_lsn_Policy {
+TExecFunc arrow_nameregexne() { return TGenericExec<TPgDirectFunc<&nameregexne>, true, true, TArgs_nameregexne_Policy>({}); }
+struct TArgs_neqjoinsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
 };
-TExecFunc arrow_numeric_pg_lsn() { return &GenericExec<TPgDirectFunc<&numeric_pg_lsn>, true, true, TArgs_numeric_pg_lsn_Policy>; }
-struct TArgs_numeric_poly_avg_Policy {
+TExecFunc arrow_neqjoinsel() { return TGenericExec<TPgDirectFunc<&neqjoinsel>, true, true, TArgs_neqjoinsel_Policy>({}); }
+struct TArgs_neqsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_numeric_poly_avg() { return &GenericExec<TPgDirectFunc<&numeric_poly_avg>, false, false, TArgs_numeric_poly_avg_Policy>; }
-struct TArgs_numeric_poly_combine_Policy {
+TExecFunc arrow_neqsel() { return TGenericExec<TPgDirectFunc<&neqsel>, true, true, TArgs_neqsel_Policy>({}); }
+struct TArgs_network_broadcast_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_numeric_poly_combine() { return &GenericExec<TPgDirectFunc<&numeric_poly_combine>, false, true, TArgs_numeric_poly_combine_Policy>; }
-struct TArgs_numeric_poly_deserialize_Policy {
+TExecFunc arrow_network_broadcast() { return TGenericExec<TPgDirectFunc<&network_broadcast>, true, false, TArgs_network_broadcast_Policy>({}); }
+struct TArgs_network_cmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_poly_deserialize() { return &GenericExec<TPgDirectFunc<&numeric_poly_deserialize>, true, true, TArgs_numeric_poly_deserialize_Policy>; }
-struct TArgs_numeric_poly_serialize_Policy {
+TExecFunc arrow_network_cmp() { return TGenericExec<TPgDirectFunc<&network_cmp>, true, true, TArgs_network_cmp_Policy>({}); }
+struct TArgs_network_eq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_poly_serialize() { return &GenericExec<TPgDirectFunc<&numeric_poly_serialize>, true, false, TArgs_numeric_poly_serialize_Policy>; }
-struct TArgs_numeric_poly_stddev_pop_Policy {
+TExecFunc arrow_network_eq() { return TGenericExec<TPgDirectFunc<&network_eq>, true, true, TArgs_network_eq_Policy>({}); }
+struct TArgs_network_family_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_numeric_poly_stddev_pop() { return &GenericExec<TPgDirectFunc<&numeric_poly_stddev_pop>, false, false, TArgs_numeric_poly_stddev_pop_Policy>; }
-struct TArgs_numeric_poly_stddev_samp_Policy {
+TExecFunc arrow_network_family() { return TGenericExec<TPgDirectFunc<&network_family>, true, true, TArgs_network_family_Policy>({}); }
+struct TArgs_network_ge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_poly_stddev_samp() { return &GenericExec<TPgDirectFunc<&numeric_poly_stddev_samp>, false, false, TArgs_numeric_poly_stddev_samp_Policy>; }
-struct TArgs_numeric_poly_sum_Policy {
+TExecFunc arrow_network_ge() { return TGenericExec<TPgDirectFunc<&network_ge>, true, true, TArgs_network_ge_Policy>({}); }
+struct TArgs_network_gt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_poly_sum() { return &GenericExec<TPgDirectFunc<&numeric_poly_sum>, false, false, TArgs_numeric_poly_sum_Policy>; }
-struct TArgs_numeric_poly_var_pop_Policy {
+TExecFunc arrow_network_gt() { return TGenericExec<TPgDirectFunc<&network_gt>, true, true, TArgs_network_gt_Policy>({}); }
+struct TArgs_network_host_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_numeric_poly_var_pop() { return &GenericExec<TPgDirectFunc<&numeric_poly_var_pop>, false, false, TArgs_numeric_poly_var_pop_Policy>; }
-struct TArgs_numeric_poly_var_samp_Policy {
+TExecFunc arrow_network_host() { return TGenericExec<TPgDirectFunc<&network_host>, true, false, TArgs_network_host_Policy>({}); }
+struct TArgs_network_hostmask_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_numeric_poly_var_samp() { return &GenericExec<TPgDirectFunc<&numeric_poly_var_samp>, false, false, TArgs_numeric_poly_var_samp_Policy>; }
-struct TArgs_numeric_power_Policy {
+TExecFunc arrow_network_hostmask() { return TGenericExec<TPgDirectFunc<&network_hostmask>, true, false, TArgs_network_hostmask_Policy>({}); }
+struct TArgs_network_larger_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_power() { return &GenericExec<TPgDirectFunc<&numeric_power>, true, false, TArgs_numeric_power_Policy>; }
-struct TArgs_numeric_recv_Policy {
+TExecFunc arrow_network_larger() { return TGenericExec<TPgDirectFunc<&network_larger>, true, false, TArgs_network_larger_Policy>({}); }
+struct TArgs_network_le_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_recv() { return &GenericExec<TPgDirectFunc<&numeric_recv>, true, false, TArgs_numeric_recv_Policy>; }
-struct TArgs_numeric_round_Policy {
+TExecFunc arrow_network_le() { return TGenericExec<TPgDirectFunc<&network_le>, true, true, TArgs_network_le_Policy>({}); }
+struct TArgs_network_lt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_round() { return &GenericExec<TPgDirectFunc<&numeric_round>, true, false, TArgs_numeric_round_Policy>; }
-struct TArgs_numeric_scale_Policy {
+TExecFunc arrow_network_lt() { return TGenericExec<TPgDirectFunc<&network_lt>, true, true, TArgs_network_lt_Policy>({}); }
+struct TArgs_network_masklen_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_numeric_scale() { return &GenericExec<TPgDirectFunc<&numeric_scale>, true, true, TArgs_numeric_scale_Policy>; }
-struct TArgs_numeric_send_Policy {
+TExecFunc arrow_network_masklen() { return TGenericExec<TPgDirectFunc<&network_masklen>, true, true, TArgs_network_masklen_Policy>({}); }
+struct TArgs_network_ne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_send() { return &GenericExec<TPgDirectFunc<&numeric_send>, true, false, TArgs_numeric_send_Policy>; }
-struct TArgs_numeric_serialize_Policy {
+TExecFunc arrow_network_ne() { return TGenericExec<TPgDirectFunc<&network_ne>, true, true, TArgs_network_ne_Policy>({}); }
+struct TArgs_network_netmask_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_numeric_serialize() { return &GenericExec<TPgDirectFunc<&numeric_serialize>, true, false, TArgs_numeric_serialize_Policy>; }
-struct TArgs_numeric_sign_Policy {
+TExecFunc arrow_network_netmask() { return TGenericExec<TPgDirectFunc<&network_netmask>, true, false, TArgs_network_netmask_Policy>({}); }
+struct TArgs_network_network_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_numeric_sign() { return &GenericExec<TPgDirectFunc<&numeric_sign>, true, false, TArgs_numeric_sign_Policy>; }
-struct TArgs_numeric_smaller_Policy {
+TExecFunc arrow_network_network() { return TGenericExec<TPgDirectFunc<&network_network>, true, false, TArgs_network_network_Policy>({}); }
+struct TArgs_network_overlap_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_smaller() { return &GenericExec<TPgDirectFunc<&numeric_smaller>, true, false, TArgs_numeric_smaller_Policy>; }
-struct TArgs_numeric_sortsupport_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_numeric_sortsupport() { return &GenericExec<TPgDirectFunc<&numeric_sortsupport>, true, true, TArgs_numeric_sortsupport_Policy>; }
-struct TArgs_numeric_sqrt_Policy {
+TExecFunc arrow_network_overlap() { return TGenericExec<TPgDirectFunc<&network_overlap>, true, true, TArgs_network_overlap_Policy>({}); }
+struct TArgs_network_show_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_numeric_sqrt() { return &GenericExec<TPgDirectFunc<&numeric_sqrt>, true, false, TArgs_numeric_sqrt_Policy>; }
-struct TArgs_numeric_stddev_pop_Policy {
+TExecFunc arrow_network_show() { return TGenericExec<TPgDirectFunc<&network_show>, true, false, TArgs_network_show_Policy>({}); }
+struct TArgs_network_smaller_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_stddev_pop() { return &GenericExec<TPgDirectFunc<&numeric_stddev_pop>, false, false, TArgs_numeric_stddev_pop_Policy>; }
-struct TArgs_numeric_stddev_samp_Policy {
+TExecFunc arrow_network_smaller() { return TGenericExec<TPgDirectFunc<&network_smaller>, true, false, TArgs_network_smaller_Policy>({}); }
+struct TArgs_network_sortsupport_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_numeric_stddev_samp() { return &GenericExec<TPgDirectFunc<&numeric_stddev_samp>, false, false, TArgs_numeric_stddev_samp_Policy>; }
-struct TArgs_numeric_sub_Policy {
+TExecFunc arrow_network_sortsupport() { return TGenericExec<TPgDirectFunc<&network_sortsupport>, true, true, TArgs_network_sortsupport_Policy>({}); }
+struct TArgs_network_sub_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_sub() { return &GenericExec<TPgDirectFunc<&numeric_sub>, true, false, TArgs_numeric_sub_Policy>; }
-struct TArgs_numeric_sum_Policy {
+TExecFunc arrow_network_sub() { return TGenericExec<TPgDirectFunc<&network_sub>, true, true, TArgs_network_sub_Policy>({}); }
+struct TArgs_network_subeq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_sum() { return &GenericExec<TPgDirectFunc<&numeric_sum>, false, false, TArgs_numeric_sum_Policy>; }
-struct TArgs_numeric_support_Policy {
+TExecFunc arrow_network_subeq() { return TGenericExec<TPgDirectFunc<&network_subeq>, true, true, TArgs_network_subeq_Policy>({}); }
+struct TArgs_network_subset_support_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_numeric_support() { return &GenericExec<TPgDirectFunc<&numeric_support>, true, true, TArgs_numeric_support_Policy>; }
-struct TArgs_numeric_trim_scale_Policy {
+TExecFunc arrow_network_subset_support() { return TGenericExec<TPgDirectFunc<&network_subset_support>, true, true, TArgs_network_subset_support_Policy>({}); }
+struct TArgs_network_sup_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_trim_scale() { return &GenericExec<TPgDirectFunc<&numeric_trim_scale>, true, false, TArgs_numeric_trim_scale_Policy>; }
-struct TArgs_numeric_trunc_Policy {
+TExecFunc arrow_network_sup() { return TGenericExec<TPgDirectFunc<&network_sup>, true, true, TArgs_network_sup_Policy>({}); }
+struct TArgs_network_supeq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_trunc() { return &GenericExec<TPgDirectFunc<&numeric_trunc>, true, false, TArgs_numeric_trunc_Policy>; }
-struct TArgs_numeric_uminus_Policy {
+TExecFunc arrow_network_supeq() { return TGenericExec<TPgDirectFunc<&network_supeq>, true, true, TArgs_network_supeq_Policy>({}); }
+struct TArgs_numrange_subdiff_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_numeric_uminus() { return &GenericExec<TPgDirectFunc<&numeric_uminus>, true, false, TArgs_numeric_uminus_Policy>; }
-struct TArgs_numeric_uplus_Policy {
+TExecFunc arrow_numrange_subdiff() { return TGenericExec<TPgDirectFunc<&numrange_subdiff>, true, true, TArgs_numrange_subdiff_Policy>({}); }
+struct TArgs_oideq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_numeric_uplus() { return &GenericExec<TPgDirectFunc<&numeric_uplus>, true, false, TArgs_numeric_uplus_Policy>; }
-struct TArgs_numeric_var_pop_Policy {
+TExecFunc arrow_oideq() { return TGenericExec<TPgDirectFunc<&oideq>, true, true, TArgs_oideq_Policy>({}); }
+struct TArgs_oidge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_numeric_var_pop() { return &GenericExec<TPgDirectFunc<&numeric_var_pop>, false, false, TArgs_numeric_var_pop_Policy>; }
-struct TArgs_numeric_var_samp_Policy {
+TExecFunc arrow_oidge() { return TGenericExec<TPgDirectFunc<&oidge>, true, true, TArgs_oidge_Policy>({}); }
+struct TArgs_oidgt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_numeric_var_samp() { return &GenericExec<TPgDirectFunc<&numeric_var_samp>, false, false, TArgs_numeric_var_samp_Policy>; }
-struct TArgs_numerictypmodin_Policy {
+TExecFunc arrow_oidgt() { return TGenericExec<TPgDirectFunc<&oidgt>, true, true, TArgs_oidgt_Policy>({}); }
+struct TArgs_oidin_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_numerictypmodin() { return &GenericExec<TPgDirectFunc<&numerictypmodin>, true, true, TArgs_numerictypmodin_Policy>; }
-struct TArgs_numerictypmodout_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_numerictypmodout() { return &GenericExec<TPgDirectFunc<&numerictypmodout>, true, false, TArgs_numerictypmodout_Policy>; }
-struct TArgs_ordered_set_transition_Policy {
+TExecFunc arrow_oidin() { return TGenericExec<TPgDirectFunc<&oidin>, true, true, TArgs_oidin_Policy>({}); }
+struct TArgs_oidlarger_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_ordered_set_transition() { return &GenericExec<TPgDirectFunc<&ordered_set_transition>, false, true, TArgs_ordered_set_transition_Policy>; }
-struct TArgs_overlaps_timestamp_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
-};
-TExecFunc arrow_overlaps_timestamp() { return &GenericExec<TPgDirectFunc<&overlaps_timestamp>, false, true, TArgs_overlaps_timestamp_Policy>; }
-struct TArgs_percentile_cont_float8_final_Policy {
+TExecFunc arrow_oidlarger() { return TGenericExec<TPgDirectFunc<&oidlarger>, true, true, TArgs_oidlarger_Policy>({}); }
+struct TArgs_oidle_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_percentile_cont_float8_final() { return &GenericExec<TPgDirectFunc<&percentile_cont_float8_final>, false, true, TArgs_percentile_cont_float8_final_Policy>; }
-struct TArgs_percentile_cont_float8_multi_final_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
-};
-TExecFunc arrow_percentile_cont_float8_multi_final() { return &GenericExec<TPgDirectFunc<&percentile_cont_float8_multi_final>, false, false, TArgs_percentile_cont_float8_multi_final_Policy>; }
-struct TArgs_percentile_cont_interval_final_Policy {
+TExecFunc arrow_oidle() { return TGenericExec<TPgDirectFunc<&oidle>, true, true, TArgs_oidle_Policy>({}); }
+struct TArgs_oidlt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_percentile_cont_interval_final() { return &GenericExec<TPgDirectFunc<&percentile_cont_interval_final>, false, false, TArgs_percentile_cont_interval_final_Policy>; }
-struct TArgs_percentile_cont_interval_multi_final_Policy {
+TExecFunc arrow_oidlt() { return TGenericExec<TPgDirectFunc<&oidlt>, true, true, TArgs_oidlt_Policy>({}); }
+struct TArgs_oidne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_percentile_cont_interval_multi_final() { return &GenericExec<TPgDirectFunc<&percentile_cont_interval_multi_final>, false, false, TArgs_percentile_cont_interval_multi_final_Policy>; }
-struct TArgs_percentile_disc_final_Policy {
+TExecFunc arrow_oidne() { return TGenericExec<TPgDirectFunc<&oidne>, true, true, TArgs_oidne_Policy>({}); }
+struct TArgs_oidout_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_percentile_disc_final() { return &GenericExec<TPgDirectFunc<&percentile_disc_final>, false, true, TArgs_percentile_disc_final_Policy>; }
-struct TArgs_percentile_disc_multi_final_Policy {
+TExecFunc arrow_oidout() { return TGenericExec<TPgDirectFunc<&oidout>, true, false, TArgs_oidout_Policy>({}); }
+struct TArgs_oidrecv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_percentile_disc_multi_final() { return &GenericExec<TPgDirectFunc<&percentile_disc_multi_final>, false, false, TArgs_percentile_disc_multi_final_Policy>; }
-struct TArgs_pg_cancel_backend_Policy {
+TExecFunc arrow_oidrecv() { return TGenericExec<TPgDirectFunc<&oidrecv>, true, true, TArgs_oidrecv_Policy>({}); }
+struct TArgs_oidsend_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_cancel_backend() { return &GenericExec<TPgDirectFunc<&pg_cancel_backend>, true, true, TArgs_pg_cancel_backend_Policy>; }
-struct TArgs_pg_conf_load_time_Policy {
+TExecFunc arrow_oidsend() { return TGenericExec<TPgDirectFunc<&oidsend>, true, false, TArgs_oidsend_Policy>({}); }
+struct TArgs_oidsmaller_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_conf_load_time() { return &GenericExec<TPgDirectFunc<&pg_conf_load_time>, true, true, TArgs_pg_conf_load_time_Policy>; }
-struct TArgs_pg_current_snapshot_Policy {
+TExecFunc arrow_oidsmaller() { return TGenericExec<TPgDirectFunc<&oidsmaller>, true, true, TArgs_oidsmaller_Policy>({}); }
+struct TArgs_oidvectoreq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_current_snapshot() { return &GenericExec<TPgDirectFunc<&pg_current_snapshot>, true, false, TArgs_pg_current_snapshot_Policy>; }
-struct TArgs_pg_current_xact_id_Policy {
+TExecFunc arrow_oidvectoreq() { return TGenericExec<TPgDirectFunc<&oidvectoreq>, true, true, TArgs_oidvectoreq_Policy>({}); }
+struct TArgs_oidvectorge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_current_xact_id() { return &GenericExec<TPgDirectFunc<&pg_current_xact_id>, true, true, TArgs_pg_current_xact_id_Policy>; }
-struct TArgs_pg_current_xact_id_if_assigned_Policy {
+TExecFunc arrow_oidvectorge() { return TGenericExec<TPgDirectFunc<&oidvectorge>, true, true, TArgs_oidvectorge_Policy>({}); }
+struct TArgs_oidvectorgt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_current_xact_id_if_assigned() { return &GenericExec<TPgDirectFunc<&pg_current_xact_id_if_assigned>, true, true, TArgs_pg_current_xact_id_if_assigned_Policy>; }
-struct TArgs_pg_ddl_command_in_Policy {
+TExecFunc arrow_oidvectorgt() { return TGenericExec<TPgDirectFunc<&oidvectorgt>, true, true, TArgs_oidvectorgt_Policy>({}); }
+struct TArgs_oidvectorin_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_ddl_command_in() { return &GenericExec<TPgDirectFunc<&pg_ddl_command_in>, true, true, TArgs_pg_ddl_command_in_Policy>; }
-struct TArgs_pg_ddl_command_out_Policy {
+TExecFunc arrow_oidvectorin() { return TGenericExec<TPgDirectFunc<&oidvectorin>, true, false, TArgs_oidvectorin_Policy>({}); }
+struct TArgs_oidvectorle_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_ddl_command_out() { return &GenericExec<TPgDirectFunc<&pg_ddl_command_out>, true, false, TArgs_pg_ddl_command_out_Policy>; }
-struct TArgs_pg_ddl_command_recv_Policy {
+TExecFunc arrow_oidvectorle() { return TGenericExec<TPgDirectFunc<&oidvectorle>, true, true, TArgs_oidvectorle_Policy>({}); }
+struct TArgs_oidvectorlt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_ddl_command_recv() { return &GenericExec<TPgDirectFunc<&pg_ddl_command_recv>, true, true, TArgs_pg_ddl_command_recv_Policy>; }
-struct TArgs_pg_ddl_command_send_Policy {
+TExecFunc arrow_oidvectorlt() { return TGenericExec<TPgDirectFunc<&oidvectorlt>, true, true, TArgs_oidvectorlt_Policy>({}); }
+struct TArgs_oidvectorne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_ddl_command_send() { return &GenericExec<TPgDirectFunc<&pg_ddl_command_send>, true, false, TArgs_pg_ddl_command_send_Policy>; }
-struct TArgs_pg_dependencies_in_Policy {
+TExecFunc arrow_oidvectorne() { return TGenericExec<TPgDirectFunc<&oidvectorne>, true, true, TArgs_oidvectorne_Policy>({}); }
+struct TArgs_oidvectorout_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_dependencies_in() { return &GenericExec<TPgDirectFunc<&pg_dependencies_in>, true, false, TArgs_pg_dependencies_in_Policy>; }
-struct TArgs_pg_dependencies_out_Policy {
+TExecFunc arrow_oidvectorout() { return TGenericExec<TPgDirectFunc<&oidvectorout>, true, false, TArgs_oidvectorout_Policy>({}); }
+struct TArgs_oidvectorrecv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_dependencies_out() { return &GenericExec<TPgDirectFunc<&pg_dependencies_out>, true, false, TArgs_pg_dependencies_out_Policy>; }
-struct TArgs_pg_dependencies_recv_Policy {
+TExecFunc arrow_oidvectorrecv() { return TGenericExec<TPgDirectFunc<&oidvectorrecv>, true, false, TArgs_oidvectorrecv_Policy>({}); }
+struct TArgs_oidvectorsend_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_dependencies_recv() { return &GenericExec<TPgDirectFunc<&pg_dependencies_recv>, true, false, TArgs_pg_dependencies_recv_Policy>; }
-struct TArgs_pg_dependencies_send_Policy {
+TExecFunc arrow_oidvectorsend() { return TGenericExec<TPgDirectFunc<&oidvectorsend>, true, false, TArgs_oidvectorsend_Policy>({}); }
+struct TArgs_oidvectortypes_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_dependencies_send() { return &GenericExec<TPgDirectFunc<&pg_dependencies_send>, true, false, TArgs_pg_dependencies_send_Policy>; }
-struct TArgs_pg_describe_object_Policy {
+TExecFunc arrow_oidvectortypes() { return TGenericExec<TPgDirectFunc<&oidvectortypes>, true, false, TArgs_oidvectortypes_Policy>({}); }
+struct TArgs_pg_cancel_backend_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_describe_object() { return &GenericExec<TPgDirectFunc<&pg_describe_object>, true, false, TArgs_pg_describe_object_Policy>; }
-struct TArgs_pg_export_snapshot_Policy {
+TExecFunc arrow_pg_cancel_backend() { return TGenericExec<TPgDirectFunc<&pg_cancel_backend>, true, true, TArgs_pg_cancel_backend_Policy>({}); }
+struct TArgs_pg_client_encoding_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_pg_export_snapshot() { return &GenericExec<TPgDirectFunc<&pg_export_snapshot>, true, false, TArgs_pg_export_snapshot_Policy>; }
-struct TArgs_pg_get_object_address_Policy {
+TExecFunc arrow_pg_client_encoding() { return TGenericExec<TPgDirectFunc<&pg_client_encoding>, true, false, TArgs_pg_client_encoding_Policy>({}); }
+struct TArgs_pg_convert_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
 };
-TExecFunc arrow_pg_get_object_address() { return &GenericExec<TPgDirectFunc<&pg_get_object_address>, true, false, TArgs_pg_get_object_address_Policy>; }
-struct TArgs_pg_identify_object_Policy {
+TExecFunc arrow_pg_convert() { return TGenericExec<TPgDirectFunc<&pg_convert>, true, false, TArgs_pg_convert_Policy>({}); }
+struct TArgs_pg_convert_from_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
-};
-TExecFunc arrow_pg_identify_object() { return &GenericExec<TPgDirectFunc<&pg_identify_object>, true, false, TArgs_pg_identify_object_Policy>; }
-struct TArgs_pg_identify_object_as_address_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
-};
-TExecFunc arrow_pg_identify_object_as_address() { return &GenericExec<TPgDirectFunc<&pg_identify_object_as_address>, true, false, TArgs_pg_identify_object_as_address_Policy>; }
-struct TArgs_pg_logical_emit_message_bytea_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
-};
-TExecFunc arrow_pg_logical_emit_message_bytea() { return &GenericExec<TPgDirectFunc<&pg_logical_emit_message_bytea>, true, true, TArgs_pg_logical_emit_message_bytea_Policy>; }
-struct TArgs_pg_logical_emit_message_text_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
-};
-TExecFunc arrow_pg_logical_emit_message_text() { return &GenericExec<TPgDirectFunc<&pg_logical_emit_message_text>, true, true, TArgs_pg_logical_emit_message_text_Policy>; }
-struct TArgs_pg_node_tree_in_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_node_tree_in() { return &GenericExec<TPgDirectFunc<&pg_node_tree_in>, true, false, TArgs_pg_node_tree_in_Policy>; }
-struct TArgs_pg_node_tree_out_Policy {
+TExecFunc arrow_pg_convert_from() { return TGenericExec<TPgDirectFunc<&pg_convert_from>, true, false, TArgs_pg_convert_from_Policy>({}); }
+struct TArgs_pg_convert_to_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_node_tree_out() { return &GenericExec<TPgDirectFunc<&pg_node_tree_out>, true, false, TArgs_pg_node_tree_out_Policy>; }
-struct TArgs_pg_node_tree_recv_Policy {
+TExecFunc arrow_pg_convert_to() { return TGenericExec<TPgDirectFunc<&pg_convert_to>, true, false, TArgs_pg_convert_to_Policy>({}); }
+struct TArgs_pg_encoding_max_length_sql_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_node_tree_recv() { return &GenericExec<TPgDirectFunc<&pg_node_tree_recv>, true, false, TArgs_pg_node_tree_recv_Policy>; }
-struct TArgs_pg_node_tree_send_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_pg_node_tree_send() { return &GenericExec<TPgDirectFunc<&pg_node_tree_send>, true, false, TArgs_pg_node_tree_send_Policy>; }
-struct TArgs_pg_postmaster_start_time_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
-};
-TExecFunc arrow_pg_postmaster_start_time() { return &GenericExec<TPgDirectFunc<&pg_postmaster_start_time>, true, true, TArgs_pg_postmaster_start_time_Policy>; }
-struct TArgs_pg_reload_conf_Policy {
+TExecFunc arrow_pg_encoding_max_length_sql() { return TGenericExec<TPgDirectFunc<&pg_encoding_max_length_sql>, true, true, TArgs_pg_encoding_max_length_sql_Policy>({}); }
+struct TArgs_pg_export_snapshot_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_pg_reload_conf() { return &GenericExec<TPgDirectFunc<&pg_reload_conf>, true, true, TArgs_pg_reload_conf_Policy>; }
-struct TArgs_pg_rotate_logfile_Policy {
+TExecFunc arrow_pg_export_snapshot() { return TGenericExec<TPgDirectFunc<&pg_export_snapshot>, true, false, TArgs_pg_export_snapshot_Policy>({}); }
+struct TArgs_pg_last_committed_xact_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_pg_rotate_logfile() { return &GenericExec<TPgDirectFunc<&pg_rotate_logfile>, true, true, TArgs_pg_rotate_logfile_Policy>; }
-struct TArgs_pg_rotate_logfile_v2_Policy {
+TExecFunc arrow_pg_last_committed_xact() { return TGenericExec<TPgDirectFunc<&pg_last_committed_xact>, true, false, TArgs_pg_last_committed_xact_Policy>({}); }
+struct TArgs_pg_log_backend_memory_contexts_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_rotate_logfile_v2() { return &GenericExec<TPgDirectFunc<&pg_rotate_logfile_v2>, true, true, TArgs_pg_rotate_logfile_v2_Policy>; }
-struct TArgs_pg_snapshot_in_Policy {
+TExecFunc arrow_pg_log_backend_memory_contexts() { return TGenericExec<TPgDirectFunc<&pg_log_backend_memory_contexts>, true, true, TArgs_pg_log_backend_memory_contexts_Policy>({}); }
+struct TArgs_pg_ndistinct_in_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_snapshot_in() { return &GenericExec<TPgDirectFunc<&pg_snapshot_in>, true, false, TArgs_pg_snapshot_in_Policy>; }
-struct TArgs_pg_snapshot_out_Policy {
+TExecFunc arrow_pg_ndistinct_in() { return TGenericExec<TPgDirectFunc<&pg_ndistinct_in>, true, false, TArgs_pg_ndistinct_in_Policy>({}); }
+struct TArgs_pg_ndistinct_out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_snapshot_out() { return &GenericExec<TPgDirectFunc<&pg_snapshot_out>, true, false, TArgs_pg_snapshot_out_Policy>; }
-struct TArgs_pg_snapshot_recv_Policy {
+TExecFunc arrow_pg_ndistinct_out() { return TGenericExec<TPgDirectFunc<&pg_ndistinct_out>, true, false, TArgs_pg_ndistinct_out_Policy>({}); }
+struct TArgs_pg_ndistinct_recv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_snapshot_recv() { return &GenericExec<TPgDirectFunc<&pg_snapshot_recv>, true, false, TArgs_pg_snapshot_recv_Policy>; }
-struct TArgs_pg_snapshot_send_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_pg_snapshot_send() { return &GenericExec<TPgDirectFunc<&pg_snapshot_send>, true, false, TArgs_pg_snapshot_send_Policy>; }
-struct TArgs_pg_snapshot_xmax_Policy {
+TExecFunc arrow_pg_ndistinct_recv() { return TGenericExec<TPgDirectFunc<&pg_ndistinct_recv>, true, false, TArgs_pg_ndistinct_recv_Policy>({}); }
+struct TArgs_pg_ndistinct_send_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_snapshot_xmax() { return &GenericExec<TPgDirectFunc<&pg_snapshot_xmax>, true, true, TArgs_pg_snapshot_xmax_Policy>; }
-struct TArgs_pg_snapshot_xmin_Policy {
+TExecFunc arrow_pg_ndistinct_send() { return TGenericExec<TPgDirectFunc<&pg_ndistinct_send>, true, false, TArgs_pg_ndistinct_send_Policy>({}); }
+struct TArgs_pg_nextoid_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,false,true};
 };
-TExecFunc arrow_pg_snapshot_xmin() { return &GenericExec<TPgDirectFunc<&pg_snapshot_xmin>, true, true, TArgs_pg_snapshot_xmin_Policy>; }
-struct TArgs_pg_stat_get_wal_receiver_Policy {
+TExecFunc arrow_pg_nextoid() { return TGenericExec<TPgDirectFunc<&pg_nextoid>, true, true, TArgs_pg_nextoid_Policy>({}); }
+struct TArgs_pg_reload_conf_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_pg_stat_get_wal_receiver() { return &GenericExec<TPgDirectFunc<&pg_stat_get_wal_receiver>, false, false, TArgs_pg_stat_get_wal_receiver_Policy>; }
-struct TArgs_pg_terminate_backend_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
-};
-TExecFunc arrow_pg_terminate_backend() { return &GenericExec<TPgDirectFunc<&pg_terminate_backend>, true, true, TArgs_pg_terminate_backend_Policy>; }
-struct TArgs_pg_visible_in_snapshot_Policy {
+TExecFunc arrow_pg_reload_conf() { return TGenericExec<TPgDirectFunc<&pg_reload_conf>, true, true, TArgs_pg_reload_conf_Policy>({}); }
+struct TArgs_pg_replication_origin_advance_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
-};
-TExecFunc arrow_pg_visible_in_snapshot() { return &GenericExec<TPgDirectFunc<&pg_visible_in_snapshot>, true, true, TArgs_pg_visible_in_snapshot_Policy>; }
-struct TArgs_pg_xact_status_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_pg_xact_status() { return &GenericExec<TPgDirectFunc<&pg_xact_status>, true, false, TArgs_pg_xact_status_Policy>; }
-struct TArgs_phraseto_tsquery_Policy {
+TExecFunc arrow_pg_replication_origin_advance() { return TGenericExec<TPgDirectFunc<&pg_replication_origin_advance>, true, true, TArgs_pg_replication_origin_advance_Policy>({}); }
+struct TArgs_pg_replication_origin_create_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_phraseto_tsquery() { return &GenericExec<TPgDirectFunc<&phraseto_tsquery>, true, false, TArgs_phraseto_tsquery_Policy>; }
-struct TArgs_phraseto_tsquery_byid_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
-};
-TExecFunc arrow_phraseto_tsquery_byid() { return &GenericExec<TPgDirectFunc<&phraseto_tsquery_byid>, true, false, TArgs_phraseto_tsquery_byid_Policy>; }
-struct TArgs_plainto_tsquery_Policy {
+TExecFunc arrow_pg_replication_origin_create() { return TGenericExec<TPgDirectFunc<&pg_replication_origin_create>, true, true, TArgs_pg_replication_origin_create_Policy>({}); }
+struct TArgs_pg_replication_origin_drop_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_plainto_tsquery() { return &GenericExec<TPgDirectFunc<&plainto_tsquery>, true, false, TArgs_plainto_tsquery_Policy>; }
-struct TArgs_plainto_tsquery_byid_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
-};
-TExecFunc arrow_plainto_tsquery_byid() { return &GenericExec<TPgDirectFunc<&plainto_tsquery_byid>, true, false, TArgs_plainto_tsquery_byid_Policy>; }
-struct TArgs_prefixjoinsel_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
-};
-TExecFunc arrow_prefixjoinsel() { return &GenericExec<TPgDirectFunc<&prefixjoinsel>, true, true, TArgs_prefixjoinsel_Policy>; }
-struct TArgs_prefixsel_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
-};
-TExecFunc arrow_prefixsel() { return &GenericExec<TPgDirectFunc<&prefixsel>, true, true, TArgs_prefixsel_Policy>; }
-struct TArgs_prsd_end_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_prsd_end() { return &GenericExec<TPgDirectFunc<&prsd_end>, true, true, TArgs_prsd_end_Policy>; }
-struct TArgs_prsd_headline_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
-};
-TExecFunc arrow_prsd_headline() { return &GenericExec<TPgDirectFunc<&prsd_headline>, true, true, TArgs_prsd_headline_Policy>; }
-struct TArgs_prsd_lextype_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_prsd_lextype() { return &GenericExec<TPgDirectFunc<&prsd_lextype>, true, true, TArgs_prsd_lextype_Policy>; }
-struct TArgs_prsd_nexttoken_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
-};
-TExecFunc arrow_prsd_nexttoken() { return &GenericExec<TPgDirectFunc<&prsd_nexttoken>, true, true, TArgs_prsd_nexttoken_Policy>; }
-struct TArgs_prsd_start_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
-};
-TExecFunc arrow_prsd_start() { return &GenericExec<TPgDirectFunc<&prsd_start>, true, true, TArgs_prsd_start_Policy>; }
-struct TArgs_regexeqjoinsel_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
-};
-TExecFunc arrow_regexeqjoinsel() { return &GenericExec<TPgDirectFunc<&regexeqjoinsel>, true, true, TArgs_regexeqjoinsel_Policy>; }
-struct TArgs_regexeqsel_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
-};
-TExecFunc arrow_regexeqsel() { return &GenericExec<TPgDirectFunc<&regexeqsel>, true, true, TArgs_regexeqsel_Policy>; }
-struct TArgs_regexnejoinsel_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
-};
-TExecFunc arrow_regexnejoinsel() { return &GenericExec<TPgDirectFunc<&regexnejoinsel>, true, true, TArgs_regexnejoinsel_Policy>; }
-struct TArgs_regexnesel_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
-};
-TExecFunc arrow_regexnesel() { return &GenericExec<TPgDirectFunc<&regexnesel>, true, true, TArgs_regexnesel_Policy>; }
-struct TArgs_shell_in_Policy {
+TExecFunc arrow_pg_replication_origin_drop() { return TGenericExec<TPgDirectFunc<&pg_replication_origin_drop>, true, true, TArgs_pg_replication_origin_drop_Policy>({}); }
+struct TArgs_pg_replication_origin_oid_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_shell_in() { return &GenericExec<TPgDirectFunc<&shell_in>, false, true, TArgs_shell_in_Policy>; }
-struct TArgs_shell_out_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_shell_out() { return &GenericExec<TPgDirectFunc<&shell_out>, true, false, TArgs_shell_out_Policy>; }
-struct TArgs_spg_bbox_quad_config_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
-};
-TExecFunc arrow_spg_bbox_quad_config() { return &GenericExec<TPgDirectFunc<&spg_bbox_quad_config>, true, true, TArgs_spg_bbox_quad_config_Policy>; }
-struct TArgs_spg_box_quad_choose_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
-};
-TExecFunc arrow_spg_box_quad_choose() { return &GenericExec<TPgDirectFunc<&spg_box_quad_choose>, true, true, TArgs_spg_box_quad_choose_Policy>; }
-struct TArgs_spg_box_quad_config_Policy {
+TExecFunc arrow_pg_replication_origin_oid() { return TGenericExec<TPgDirectFunc<&pg_replication_origin_oid>, true, true, TArgs_pg_replication_origin_oid_Policy>({}); }
+struct TArgs_pg_replication_origin_progress_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_spg_box_quad_config() { return &GenericExec<TPgDirectFunc<&spg_box_quad_config>, true, true, TArgs_spg_box_quad_config_Policy>; }
-struct TArgs_spg_box_quad_inner_consistent_Policy {
+TExecFunc arrow_pg_replication_origin_progress() { return TGenericExec<TPgDirectFunc<&pg_replication_origin_progress>, true, true, TArgs_pg_replication_origin_progress_Policy>({}); }
+struct TArgs_pg_replication_origin_session_is_setup_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_spg_box_quad_inner_consistent() { return &GenericExec<TPgDirectFunc<&spg_box_quad_inner_consistent>, true, true, TArgs_spg_box_quad_inner_consistent_Policy>; }
-struct TArgs_spg_box_quad_leaf_consistent_Policy {
+TExecFunc arrow_pg_replication_origin_session_is_setup() { return TGenericExec<TPgDirectFunc<&pg_replication_origin_session_is_setup>, true, true, TArgs_pg_replication_origin_session_is_setup_Policy>({}); }
+struct TArgs_pg_replication_origin_session_progress_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_spg_box_quad_leaf_consistent() { return &GenericExec<TPgDirectFunc<&spg_box_quad_leaf_consistent>, true, true, TArgs_spg_box_quad_leaf_consistent_Policy>; }
-struct TArgs_spg_box_quad_picksplit_Policy {
+TExecFunc arrow_pg_replication_origin_session_progress() { return TGenericExec<TPgDirectFunc<&pg_replication_origin_session_progress>, true, true, TArgs_pg_replication_origin_session_progress_Policy>({}); }
+struct TArgs_pg_replication_origin_session_reset_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_spg_box_quad_picksplit() { return &GenericExec<TPgDirectFunc<&spg_box_quad_picksplit>, true, true, TArgs_spg_box_quad_picksplit_Policy>; }
-struct TArgs_spg_poly_quad_compress_Policy {
+TExecFunc arrow_pg_replication_origin_session_reset() { return TGenericExec<TPgDirectFunc<&pg_replication_origin_session_reset>, true, true, TArgs_pg_replication_origin_session_reset_Policy>({}); }
+struct TArgs_pg_replication_origin_session_setup_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_spg_poly_quad_compress() { return &GenericExec<TPgDirectFunc<&spg_poly_quad_compress>, true, false, TArgs_spg_poly_quad_compress_Policy>; }
-struct TArgs_spg_quad_choose_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
-};
-TExecFunc arrow_spg_quad_choose() { return &GenericExec<TPgDirectFunc<&spg_quad_choose>, true, true, TArgs_spg_quad_choose_Policy>; }
-struct TArgs_spg_quad_config_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
-};
-TExecFunc arrow_spg_quad_config() { return &GenericExec<TPgDirectFunc<&spg_quad_config>, true, true, TArgs_spg_quad_config_Policy>; }
-struct TArgs_spg_quad_inner_consistent_Policy {
+TExecFunc arrow_pg_replication_origin_session_setup() { return TGenericExec<TPgDirectFunc<&pg_replication_origin_session_setup>, true, true, TArgs_pg_replication_origin_session_setup_Policy>({}); }
+struct TArgs_pg_replication_origin_xact_reset_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
-};
-TExecFunc arrow_spg_quad_inner_consistent() { return &GenericExec<TPgDirectFunc<&spg_quad_inner_consistent>, true, true, TArgs_spg_quad_inner_consistent_Policy>; }
-struct TArgs_spg_quad_leaf_consistent_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
-};
-TExecFunc arrow_spg_quad_leaf_consistent() { return &GenericExec<TPgDirectFunc<&spg_quad_leaf_consistent>, true, true, TArgs_spg_quad_leaf_consistent_Policy>; }
-struct TArgs_spg_quad_picksplit_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
-};
-TExecFunc arrow_spg_quad_picksplit() { return &GenericExec<TPgDirectFunc<&spg_quad_picksplit>, true, true, TArgs_spg_quad_picksplit_Policy>; }
-struct TArgs_spg_range_quad_choose_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
-};
-TExecFunc arrow_spg_range_quad_choose() { return &GenericExec<TPgDirectFunc<&spg_range_quad_choose>, true, true, TArgs_spg_range_quad_choose_Policy>; }
-struct TArgs_spg_range_quad_config_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
-};
-TExecFunc arrow_spg_range_quad_config() { return &GenericExec<TPgDirectFunc<&spg_range_quad_config>, true, true, TArgs_spg_range_quad_config_Policy>; }
-struct TArgs_spg_range_quad_inner_consistent_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
-};
-TExecFunc arrow_spg_range_quad_inner_consistent() { return &GenericExec<TPgDirectFunc<&spg_range_quad_inner_consistent>, true, true, TArgs_spg_range_quad_inner_consistent_Policy>; }
-struct TArgs_spg_range_quad_leaf_consistent_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_spg_range_quad_leaf_consistent() { return &GenericExec<TPgDirectFunc<&spg_range_quad_leaf_consistent>, true, true, TArgs_spg_range_quad_leaf_consistent_Policy>; }
-struct TArgs_spg_range_quad_picksplit_Policy {
+TExecFunc arrow_pg_replication_origin_xact_reset() { return TGenericExec<TPgDirectFunc<&pg_replication_origin_xact_reset>, true, true, TArgs_pg_replication_origin_xact_reset_Policy>({}); }
+struct TArgs_pg_replication_origin_xact_setup_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_spg_range_quad_picksplit() { return &GenericExec<TPgDirectFunc<&spg_range_quad_picksplit>, true, true, TArgs_spg_range_quad_picksplit_Policy>; }
-struct TArgs_spghandler_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_spghandler() { return &GenericExec<TPgDirectFunc<&spghandler>, true, true, TArgs_spghandler_Policy>; }
-struct TArgs_statement_timestamp_Policy {
+TExecFunc arrow_pg_replication_origin_xact_setup() { return TGenericExec<TPgDirectFunc<&pg_replication_origin_xact_setup>, true, true, TArgs_pg_replication_origin_xact_setup_Policy>({}); }
+struct TArgs_pg_rotate_logfile_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_statement_timestamp() { return &GenericExec<TPgDirectFunc<&statement_timestamp>, true, true, TArgs_statement_timestamp_Policy>; }
-struct TArgs_suppress_redundant_updates_trigger_Policy {
+TExecFunc arrow_pg_rotate_logfile() { return TGenericExec<TPgDirectFunc<&pg_rotate_logfile>, true, true, TArgs_pg_rotate_logfile_Policy>({}); }
+struct TArgs_pg_rotate_logfile_v2_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_suppress_redundant_updates_trigger() { return &GenericExec<TPgDirectFunc<&suppress_redundant_updates_trigger>, true, true, TArgs_suppress_redundant_updates_trigger_Policy>; }
-struct TArgs_table_am_handler_in_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_table_am_handler_in() { return &GenericExec<TPgDirectFunc<&table_am_handler_in>, false, true, TArgs_table_am_handler_in_Policy>; }
-struct TArgs_table_am_handler_out_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_table_am_handler_out() { return &GenericExec<TPgDirectFunc<&table_am_handler_out>, true, false, TArgs_table_am_handler_out_Policy>; }
-struct TArgs_texticlike_support_Policy {
+TExecFunc arrow_pg_rotate_logfile_v2() { return TGenericExec<TPgDirectFunc<&pg_rotate_logfile_v2>, true, true, TArgs_pg_rotate_logfile_v2_Policy>({}); }
+struct TArgs_pg_terminate_backend_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_texticlike_support() { return &GenericExec<TPgDirectFunc<&texticlike_support>, true, true, TArgs_texticlike_support_Policy>; }
-struct TArgs_texticregexeq_support_Policy {
+TExecFunc arrow_pg_terminate_backend() { return TGenericExec<TPgDirectFunc<&pg_terminate_backend>, true, true, TArgs_pg_terminate_backend_Policy>({}); }
+struct TArgs_pg_xact_commit_timestamp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_texticregexeq_support() { return &GenericExec<TPgDirectFunc<&texticregexeq_support>, true, true, TArgs_texticregexeq_support_Policy>; }
-struct TArgs_textlike_support_Policy {
+TExecFunc arrow_pg_xact_commit_timestamp() { return TGenericExec<TPgDirectFunc<&pg_xact_commit_timestamp>, true, true, TArgs_pg_xact_commit_timestamp_Policy>({}); }
+struct TArgs_pg_xact_commit_timestamp_origin_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_textlike_support() { return &GenericExec<TPgDirectFunc<&textlike_support>, true, true, TArgs_textlike_support_Policy>; }
-struct TArgs_textregexeq_support_Policy {
+TExecFunc arrow_pg_xact_commit_timestamp_origin() { return TGenericExec<TPgDirectFunc<&pg_xact_commit_timestamp_origin>, true, false, TArgs_pg_xact_commit_timestamp_origin_Policy>({}); }
+struct TArgs_pgsql_version_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_textregexeq_support() { return &GenericExec<TPgDirectFunc<&textregexeq_support>, true, true, TArgs_textregexeq_support_Policy>; }
-struct TArgs_thesaurus_init_Policy {
+TExecFunc arrow_pgsql_version() { return TGenericExec<TPgDirectFunc<&pgsql_version>, true, false, TArgs_pgsql_version_Policy>({}); }
+struct TArgs_range_adjacent_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_thesaurus_init() { return &GenericExec<TPgDirectFunc<&thesaurus_init>, true, true, TArgs_thesaurus_init_Policy>; }
-struct TArgs_thesaurus_lexize_Policy {
+TExecFunc arrow_range_adjacent() { return TGenericExec<TPgDirectFunc<&range_adjacent>, true, true, TArgs_range_adjacent_Policy>({}); }
+struct TArgs_range_after_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_thesaurus_lexize() { return &GenericExec<TPgDirectFunc<&thesaurus_lexize>, true, true, TArgs_thesaurus_lexize_Policy>; }
-struct TArgs_timeofday_Policy {
+TExecFunc arrow_range_after() { return TGenericExec<TPgDirectFunc<&range_after>, true, true, TArgs_range_after_Policy>({}); }
+struct TArgs_range_before_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timeofday() { return &GenericExec<TPgDirectFunc<&timeofday>, true, false, TArgs_timeofday_Policy>; }
-struct TArgs_timestamp_age_Policy {
+TExecFunc arrow_range_before() { return TGenericExec<TPgDirectFunc<&range_before>, true, true, TArgs_range_before_Policy>({}); }
+struct TArgs_range_cmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timestamp_age() { return &GenericExec<TPgDirectFunc<&timestamp_age>, true, false, TArgs_timestamp_age_Policy>; }
-struct TArgs_timestamp_bin_Policy {
+TExecFunc arrow_range_cmp() { return TGenericExec<TPgDirectFunc<&range_cmp>, true, true, TArgs_range_cmp_Policy>({}); }
+TExecFunc arrow_range_constructor2() { return TGenericExec<TPgDirectFunc<&range_constructor2>, false, false, TDefaultArgsPolicy>({}); }
+TExecFunc arrow_range_constructor3() { return TGenericExec<TPgDirectFunc<&range_constructor3>, false, false, TDefaultArgsPolicy>({}); }
+struct TArgs_range_contained_by_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timestamp_bin() { return &GenericExec<TPgDirectFunc<&timestamp_bin>, true, true, TArgs_timestamp_bin_Policy>; }
-struct TArgs_timestamp_cmp_Policy {
+TExecFunc arrow_range_contained_by() { return TGenericExec<TPgDirectFunc<&range_contained_by>, true, true, TArgs_range_contained_by_Policy>({}); }
+struct TArgs_range_contains_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timestamp_cmp() { return &GenericExec<TPgDirectFunc<&timestamp_cmp>, true, true, TArgs_timestamp_cmp_Policy>; }
-struct TArgs_timestamp_cmp_timestamptz_Policy {
+TExecFunc arrow_range_contains() { return TGenericExec<TPgDirectFunc<&range_contains>, true, true, TArgs_range_contains_Policy>({}); }
+struct TArgs_range_contains_elem_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_timestamp_cmp_timestamptz() { return &GenericExec<TPgDirectFunc<&timestamp_cmp_timestamptz>, true, true, TArgs_timestamp_cmp_timestamptz_Policy>; }
-struct TArgs_timestamp_eq_Policy {
+TExecFunc arrow_range_contains_elem() { return TGenericExec<TPgDirectFunc<&range_contains_elem>, true, true, TArgs_range_contains_elem_Policy>({}); }
+struct TArgs_range_empty_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_timestamp_eq() { return &GenericExec<TPgDirectFunc<&timestamp_eq>, true, true, TArgs_timestamp_eq_Policy>; }
-struct TArgs_timestamp_eq_timestamptz_Policy {
+TExecFunc arrow_range_empty() { return TGenericExec<TPgDirectFunc<&range_empty>, true, true, TArgs_range_empty_Policy>({}); }
+struct TArgs_range_eq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timestamp_eq_timestamptz() { return &GenericExec<TPgDirectFunc<&timestamp_eq_timestamptz>, true, true, TArgs_timestamp_eq_timestamptz_Policy>; }
-struct TArgs_timestamp_finite_Policy {
+TExecFunc arrow_range_eq() { return TGenericExec<TPgDirectFunc<&range_eq>, true, true, TArgs_range_eq_Policy>({}); }
+struct TArgs_range_ge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timestamp_finite() { return &GenericExec<TPgDirectFunc<&timestamp_finite>, true, true, TArgs_timestamp_finite_Policy>; }
-struct TArgs_timestamp_ge_Policy {
+TExecFunc arrow_range_ge() { return TGenericExec<TPgDirectFunc<&range_ge>, true, true, TArgs_range_ge_Policy>({}); }
+struct TArgs_range_gt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timestamp_ge() { return &GenericExec<TPgDirectFunc<&timestamp_ge>, true, true, TArgs_timestamp_ge_Policy>; }
-struct TArgs_timestamp_ge_timestamptz_Policy {
+TExecFunc arrow_range_gt() { return TGenericExec<TPgDirectFunc<&range_gt>, true, true, TArgs_range_gt_Policy>({}); }
+struct TArgs_range_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_timestamp_ge_timestamptz() { return &GenericExec<TPgDirectFunc<&timestamp_ge_timestamptz>, true, true, TArgs_timestamp_ge_timestamptz_Policy>; }
-struct TArgs_timestamp_gt_Policy {
+TExecFunc arrow_range_in() { return TGenericExec<TPgDirectFunc<&range_in>, true, false, TArgs_range_in_Policy>({}); }
+struct TArgs_range_intersect_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timestamp_gt() { return &GenericExec<TPgDirectFunc<&timestamp_gt>, true, true, TArgs_timestamp_gt_Policy>; }
-struct TArgs_timestamp_gt_timestamptz_Policy {
+TExecFunc arrow_range_intersect() { return TGenericExec<TPgDirectFunc<&range_intersect>, true, false, TArgs_range_intersect_Policy>({}); }
+struct TArgs_range_intersect_agg_transfn_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timestamp_gt_timestamptz() { return &GenericExec<TPgDirectFunc<&timestamp_gt_timestamptz>, true, true, TArgs_timestamp_gt_timestamptz_Policy>; }
-struct TArgs_timestamp_hash_Policy {
+TExecFunc arrow_range_intersect_agg_transfn() { return TGenericExec<TPgDirectFunc<&range_intersect_agg_transfn>, true, false, TArgs_range_intersect_agg_transfn_Policy>({}); }
+struct TArgs_range_le_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timestamp_hash() { return &GenericExec<TPgDirectFunc<&timestamp_hash>, true, true, TArgs_timestamp_hash_Policy>; }
-struct TArgs_timestamp_hash_extended_Policy {
+TExecFunc arrow_range_le() { return TGenericExec<TPgDirectFunc<&range_le>, true, true, TArgs_range_le_Policy>({}); }
+struct TArgs_range_lower_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_timestamp_hash_extended() { return &GenericExec<TPgDirectFunc<&timestamp_hash_extended>, true, true, TArgs_timestamp_hash_extended_Policy>; }
-struct TArgs_timestamp_in_Policy {
+TExecFunc arrow_range_lower() { return TGenericExec<TPgDirectFunc<&range_lower>, true, true, TArgs_range_lower_Policy>({}); }
+struct TArgs_range_lower_inc_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_timestamp_in() { return &GenericExec<TPgDirectFunc<&timestamp_in>, true, true, TArgs_timestamp_in_Policy>; }
-struct TArgs_timestamp_izone_Policy {
+TExecFunc arrow_range_lower_inc() { return TGenericExec<TPgDirectFunc<&range_lower_inc>, true, true, TArgs_range_lower_inc_Policy>({}); }
+struct TArgs_range_lower_inf_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_timestamp_izone() { return &GenericExec<TPgDirectFunc<&timestamp_izone>, true, true, TArgs_timestamp_izone_Policy>; }
-struct TArgs_timestamp_larger_Policy {
+TExecFunc arrow_range_lower_inf() { return TGenericExec<TPgDirectFunc<&range_lower_inf>, true, true, TArgs_range_lower_inf_Policy>({}); }
+struct TArgs_range_lt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timestamp_larger() { return &GenericExec<TPgDirectFunc<&timestamp_larger>, true, true, TArgs_timestamp_larger_Policy>; }
-struct TArgs_timestamp_le_Policy {
+TExecFunc arrow_range_lt() { return TGenericExec<TPgDirectFunc<&range_lt>, true, true, TArgs_range_lt_Policy>({}); }
+struct TArgs_range_merge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timestamp_le() { return &GenericExec<TPgDirectFunc<&timestamp_le>, true, true, TArgs_timestamp_le_Policy>; }
-struct TArgs_timestamp_le_timestamptz_Policy {
+TExecFunc arrow_range_merge() { return TGenericExec<TPgDirectFunc<&range_merge>, true, false, TArgs_range_merge_Policy>({}); }
+struct TArgs_range_minus_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timestamp_le_timestamptz() { return &GenericExec<TPgDirectFunc<&timestamp_le_timestamptz>, true, true, TArgs_timestamp_le_timestamptz_Policy>; }
-struct TArgs_timestamp_lt_Policy {
+TExecFunc arrow_range_minus() { return TGenericExec<TPgDirectFunc<&range_minus>, true, false, TArgs_range_minus_Policy>({}); }
+struct TArgs_range_ne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timestamp_lt() { return &GenericExec<TPgDirectFunc<&timestamp_lt>, true, true, TArgs_timestamp_lt_Policy>; }
-struct TArgs_timestamp_lt_timestamptz_Policy {
+TExecFunc arrow_range_ne() { return TGenericExec<TPgDirectFunc<&range_ne>, true, true, TArgs_range_ne_Policy>({}); }
+struct TArgs_range_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_timestamp_lt_timestamptz() { return &GenericExec<TPgDirectFunc<&timestamp_lt_timestamptz>, true, true, TArgs_timestamp_lt_timestamptz_Policy>; }
-struct TArgs_timestamp_mi_Policy {
+TExecFunc arrow_range_out() { return TGenericExec<TPgDirectFunc<&range_out>, true, false, TArgs_range_out_Policy>({}); }
+struct TArgs_range_overlaps_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timestamp_mi() { return &GenericExec<TPgDirectFunc<&timestamp_mi>, true, false, TArgs_timestamp_mi_Policy>; }
-struct TArgs_timestamp_mi_interval_Policy {
+TExecFunc arrow_range_overlaps() { return TGenericExec<TPgDirectFunc<&range_overlaps>, true, true, TArgs_range_overlaps_Policy>({}); }
+struct TArgs_range_overleft_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timestamp_mi_interval() { return &GenericExec<TPgDirectFunc<&timestamp_mi_interval>, true, true, TArgs_timestamp_mi_interval_Policy>; }
-struct TArgs_timestamp_ne_Policy {
+TExecFunc arrow_range_overleft() { return TGenericExec<TPgDirectFunc<&range_overleft>, true, true, TArgs_range_overleft_Policy>({}); }
+struct TArgs_range_overright_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timestamp_ne() { return &GenericExec<TPgDirectFunc<&timestamp_ne>, true, true, TArgs_timestamp_ne_Policy>; }
-struct TArgs_timestamp_ne_timestamptz_Policy {
+TExecFunc arrow_range_overright() { return TGenericExec<TPgDirectFunc<&range_overright>, true, true, TArgs_range_overright_Policy>({}); }
+struct TArgs_range_recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_timestamp_ne_timestamptz() { return &GenericExec<TPgDirectFunc<&timestamp_ne_timestamptz>, true, true, TArgs_timestamp_ne_timestamptz_Policy>; }
-struct TArgs_timestamp_out_Policy {
+TExecFunc arrow_range_recv() { return TGenericExec<TPgDirectFunc<&range_recv>, true, false, TArgs_range_recv_Policy>({}); }
+struct TArgs_range_send_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_timestamp_out() { return &GenericExec<TPgDirectFunc<&timestamp_out>, true, false, TArgs_timestamp_out_Policy>; }
-struct TArgs_timestamp_part_Policy {
+TExecFunc arrow_range_send() { return TGenericExec<TPgDirectFunc<&range_send>, true, false, TArgs_range_send_Policy>({}); }
+struct TArgs_range_union_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timestamp_part() { return &GenericExec<TPgDirectFunc<&timestamp_part>, true, true, TArgs_timestamp_part_Policy>; }
-struct TArgs_timestamp_pl_interval_Policy {
+TExecFunc arrow_range_union() { return TGenericExec<TPgDirectFunc<&range_union>, true, false, TArgs_range_union_Policy>({}); }
+struct TArgs_range_upper_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_timestamp_pl_interval() { return &GenericExec<TPgDirectFunc<&timestamp_pl_interval>, true, true, TArgs_timestamp_pl_interval_Policy>; }
-struct TArgs_timestamp_recv_Policy {
+TExecFunc arrow_range_upper() { return TGenericExec<TPgDirectFunc<&range_upper>, true, true, TArgs_range_upper_Policy>({}); }
+struct TArgs_range_upper_inc_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_timestamp_recv() { return &GenericExec<TPgDirectFunc<&timestamp_recv>, true, true, TArgs_timestamp_recv_Policy>; }
-struct TArgs_timestamp_scale_Policy {
+TExecFunc arrow_range_upper_inc() { return TGenericExec<TPgDirectFunc<&range_upper_inc>, true, true, TArgs_range_upper_inc_Policy>({}); }
+struct TArgs_range_upper_inf_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_timestamp_scale() { return &GenericExec<TPgDirectFunc<&timestamp_scale>, true, true, TArgs_timestamp_scale_Policy>; }
-struct TArgs_timestamp_send_Policy {
+TExecFunc arrow_range_upper_inf() { return TGenericExec<TPgDirectFunc<&range_upper_inf>, true, true, TArgs_range_upper_inf_Policy>({}); }
+struct TArgs_raw_array_subscript_handler_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_timestamp_send() { return &GenericExec<TPgDirectFunc<&timestamp_send>, true, false, TArgs_timestamp_send_Policy>; }
-struct TArgs_timestamp_smaller_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
-};
-TExecFunc arrow_timestamp_smaller() { return &GenericExec<TPgDirectFunc<&timestamp_smaller>, true, true, TArgs_timestamp_smaller_Policy>; }
-struct TArgs_timestamp_sortsupport_Policy {
+TExecFunc arrow_raw_array_subscript_handler() { return TGenericExec<TPgDirectFunc<&raw_array_subscript_handler>, true, true, TArgs_raw_array_subscript_handler_Policy>({}); }
+struct TArgs_regexp_match_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
 };
-TExecFunc arrow_timestamp_sortsupport() { return &GenericExec<TPgDirectFunc<&timestamp_sortsupport>, true, true, TArgs_timestamp_sortsupport_Policy>; }
-struct TArgs_timestamp_support_Policy {
+TExecFunc arrow_regexp_match() { return TGenericExec<TPgDirectFunc<&regexp_match>, true, false, TArgs_regexp_match_Policy>({}); }
+struct TArgs_regexp_match_no_flags_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timestamp_support() { return &GenericExec<TPgDirectFunc<&timestamp_support>, true, true, TArgs_timestamp_support_Policy>; }
-struct TArgs_timestamp_timestamptz_Policy {
+TExecFunc arrow_regexp_match_no_flags() { return TGenericExec<TPgDirectFunc<&regexp_match_no_flags>, true, false, TArgs_regexp_match_no_flags_Policy>({}); }
+struct TArgs_regexp_split_to_array_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
 };
-TExecFunc arrow_timestamp_timestamptz() { return &GenericExec<TPgDirectFunc<&timestamp_timestamptz>, true, true, TArgs_timestamp_timestamptz_Policy>; }
-struct TArgs_timestamp_trunc_Policy {
+TExecFunc arrow_regexp_split_to_array() { return TGenericExec<TPgDirectFunc<&regexp_split_to_array>, true, false, TArgs_regexp_split_to_array_Policy>({}); }
+struct TArgs_regexp_split_to_array_no_flags_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timestamp_trunc() { return &GenericExec<TPgDirectFunc<&timestamp_trunc>, true, true, TArgs_timestamp_trunc_Policy>; }
-struct TArgs_timestamp_zone_Policy {
+TExecFunc arrow_regexp_split_to_array_no_flags() { return TGenericExec<TPgDirectFunc<&regexp_split_to_array_no_flags>, true, false, TArgs_regexp_split_to_array_no_flags_Policy>({}); }
+struct TArgs_repeat_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_timestamp_zone() { return &GenericExec<TPgDirectFunc<&timestamp_zone>, true, true, TArgs_timestamp_zone_Policy>; }
-struct TArgs_timestamptypmodin_Policy {
+TExecFunc arrow_repeat() { return TGenericExec<TPgDirectFunc<&repeat>, true, false, TArgs_repeat_Policy>({}); }
+struct TArgs_row_to_json_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_timestamptypmodin() { return &GenericExec<TPgDirectFunc<&timestamptypmodin>, true, true, TArgs_timestamptypmodin_Policy>; }
-struct TArgs_timestamptypmodout_Policy {
+TExecFunc arrow_row_to_json() { return TGenericExec<TPgDirectFunc<&row_to_json>, true, false, TArgs_row_to_json_Policy>({}); }
+struct TArgs_row_to_json_pretty_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_timestamptypmodout() { return &GenericExec<TPgDirectFunc<&timestamptypmodout>, true, false, TArgs_timestamptypmodout_Policy>; }
-struct TArgs_timestamptz_age_Policy {
+TExecFunc arrow_row_to_json_pretty() { return TGenericExec<TPgDirectFunc<&row_to_json_pretty>, true, false, TArgs_row_to_json_pretty_Policy>({}); }
+struct TArgs_rpad_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
 };
-TExecFunc arrow_timestamptz_age() { return &GenericExec<TPgDirectFunc<&timestamptz_age>, true, false, TArgs_timestamptz_age_Policy>; }
-struct TArgs_timestamptz_bin_Policy {
+TExecFunc arrow_rpad() { return TGenericExec<TPgDirectFunc<&rpad>, true, false, TArgs_rpad_Policy>({}); }
+struct TArgs_rtrim_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timestamptz_bin() { return &GenericExec<TPgDirectFunc<&timestamptz_bin>, true, true, TArgs_timestamptz_bin_Policy>; }
-struct TArgs_timestamptz_cmp_timestamp_Policy {
+TExecFunc arrow_rtrim() { return TGenericExec<TPgDirectFunc<&rtrim>, true, false, TArgs_rtrim_Policy>({}); }
+struct TArgs_rtrim1_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_timestamptz_cmp_timestamp() { return &GenericExec<TPgDirectFunc<&timestamptz_cmp_timestamp>, true, true, TArgs_timestamptz_cmp_timestamp_Policy>; }
-struct TArgs_timestamptz_eq_timestamp_Policy {
+TExecFunc arrow_rtrim1() { return TGenericExec<TPgDirectFunc<&rtrim1>, true, false, TArgs_rtrim1_Policy>({}); }
+struct TArgs_scalargejoinsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
 };
-TExecFunc arrow_timestamptz_eq_timestamp() { return &GenericExec<TPgDirectFunc<&timestamptz_eq_timestamp>, true, true, TArgs_timestamptz_eq_timestamp_Policy>; }
-struct TArgs_timestamptz_ge_timestamp_Policy {
+TExecFunc arrow_scalargejoinsel() { return TGenericExec<TPgDirectFunc<&scalargejoinsel>, true, true, TArgs_scalargejoinsel_Policy>({}); }
+struct TArgs_scalargesel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_timestamptz_ge_timestamp() { return &GenericExec<TPgDirectFunc<&timestamptz_ge_timestamp>, true, true, TArgs_timestamptz_ge_timestamp_Policy>; }
-struct TArgs_timestamptz_gt_timestamp_Policy {
+TExecFunc arrow_scalargesel() { return TGenericExec<TPgDirectFunc<&scalargesel>, true, true, TArgs_scalargesel_Policy>({}); }
+struct TArgs_scalargtjoinsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
 };
-TExecFunc arrow_timestamptz_gt_timestamp() { return &GenericExec<TPgDirectFunc<&timestamptz_gt_timestamp>, true, true, TArgs_timestamptz_gt_timestamp_Policy>; }
-struct TArgs_timestamptz_in_Policy {
+TExecFunc arrow_scalargtjoinsel() { return TGenericExec<TPgDirectFunc<&scalargtjoinsel>, true, true, TArgs_scalargtjoinsel_Policy>({}); }
+struct TArgs_scalargtsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_timestamptz_in() { return &GenericExec<TPgDirectFunc<&timestamptz_in>, true, true, TArgs_timestamptz_in_Policy>; }
-struct TArgs_timestamptz_izone_Policy {
+TExecFunc arrow_scalargtsel() { return TGenericExec<TPgDirectFunc<&scalargtsel>, true, true, TArgs_scalargtsel_Policy>({}); }
+struct TArgs_scalarlejoinsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
 };
-TExecFunc arrow_timestamptz_izone() { return &GenericExec<TPgDirectFunc<&timestamptz_izone>, true, true, TArgs_timestamptz_izone_Policy>; }
-struct TArgs_timestamptz_le_timestamp_Policy {
+TExecFunc arrow_scalarlejoinsel() { return TGenericExec<TPgDirectFunc<&scalarlejoinsel>, true, true, TArgs_scalarlejoinsel_Policy>({}); }
+struct TArgs_scalarlesel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_timestamptz_le_timestamp() { return &GenericExec<TPgDirectFunc<&timestamptz_le_timestamp>, true, true, TArgs_timestamptz_le_timestamp_Policy>; }
-struct TArgs_timestamptz_lt_timestamp_Policy {
+TExecFunc arrow_scalarlesel() { return TGenericExec<TPgDirectFunc<&scalarlesel>, true, true, TArgs_scalarlesel_Policy>({}); }
+struct TArgs_scalarltjoinsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
 };
-TExecFunc arrow_timestamptz_lt_timestamp() { return &GenericExec<TPgDirectFunc<&timestamptz_lt_timestamp>, true, true, TArgs_timestamptz_lt_timestamp_Policy>; }
-struct TArgs_timestamptz_mi_interval_Policy {
+TExecFunc arrow_scalarltjoinsel() { return TGenericExec<TPgDirectFunc<&scalarltjoinsel>, true, true, TArgs_scalarltjoinsel_Policy>({}); }
+struct TArgs_scalarltsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_timestamptz_mi_interval() { return &GenericExec<TPgDirectFunc<&timestamptz_mi_interval>, true, true, TArgs_timestamptz_mi_interval_Policy>; }
-struct TArgs_timestamptz_ne_timestamp_Policy {
+TExecFunc arrow_scalarltsel() { return TGenericExec<TPgDirectFunc<&scalarltsel>, true, true, TArgs_scalarltsel_Policy>({}); }
+struct TArgs_set_config_by_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,true};
 };
-TExecFunc arrow_timestamptz_ne_timestamp() { return &GenericExec<TPgDirectFunc<&timestamptz_ne_timestamp>, true, true, TArgs_timestamptz_ne_timestamp_Policy>; }
-struct TArgs_timestamptz_out_Policy {
+TExecFunc arrow_set_config_by_name() { return TGenericExec<TPgDirectFunc<&set_config_by_name>, false, false, TArgs_set_config_by_name_Policy>({}); }
+struct TArgs_show_config_by_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_timestamptz_out() { return &GenericExec<TPgDirectFunc<&timestamptz_out>, true, false, TArgs_timestamptz_out_Policy>; }
-struct TArgs_timestamptz_part_Policy {
+TExecFunc arrow_show_config_by_name() { return TGenericExec<TPgDirectFunc<&show_config_by_name>, true, false, TArgs_show_config_by_name_Policy>({}); }
+struct TArgs_show_config_by_name_missing_ok_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_timestamptz_part() { return &GenericExec<TPgDirectFunc<&timestamptz_part>, true, true, TArgs_timestamptz_part_Policy>; }
-struct TArgs_timestamptz_pl_interval_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
-};
-TExecFunc arrow_timestamptz_pl_interval() { return &GenericExec<TPgDirectFunc<&timestamptz_pl_interval>, true, true, TArgs_timestamptz_pl_interval_Policy>; }
-struct TArgs_timestamptz_recv_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
-};
-TExecFunc arrow_timestamptz_recv() { return &GenericExec<TPgDirectFunc<&timestamptz_recv>, true, true, TArgs_timestamptz_recv_Policy>; }
-struct TArgs_timestamptz_scale_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
-};
-TExecFunc arrow_timestamptz_scale() { return &GenericExec<TPgDirectFunc<&timestamptz_scale>, true, true, TArgs_timestamptz_scale_Policy>; }
-struct TArgs_timestamptz_send_Policy {
+TExecFunc arrow_show_config_by_name_missing_ok() { return TGenericExec<TPgDirectFunc<&show_config_by_name_missing_ok>, true, false, TArgs_show_config_by_name_missing_ok_Policy>({}); }
+struct TArgs_similar_escape_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timestamptz_send() { return &GenericExec<TPgDirectFunc<&timestamptz_send>, true, false, TArgs_timestamptz_send_Policy>; }
-struct TArgs_timestamptz_timestamp_Policy {
+TExecFunc arrow_similar_escape() { return TGenericExec<TPgDirectFunc<&similar_escape>, false, false, TArgs_similar_escape_Policy>({}); }
+struct TArgs_similar_to_escape_1_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_timestamptz_timestamp() { return &GenericExec<TPgDirectFunc<&timestamptz_timestamp>, true, true, TArgs_timestamptz_timestamp_Policy>; }
-struct TArgs_timestamptz_trunc_Policy {
+TExecFunc arrow_similar_to_escape_1() { return TGenericExec<TPgDirectFunc<&similar_to_escape_1>, true, false, TArgs_similar_to_escape_1_Policy>({}); }
+struct TArgs_similar_to_escape_2_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timestamptz_trunc() { return &GenericExec<TPgDirectFunc<&timestamptz_trunc>, true, true, TArgs_timestamptz_trunc_Policy>; }
-struct TArgs_timestamptz_trunc_zone_Policy {
+TExecFunc arrow_similar_to_escape_2() { return TGenericExec<TPgDirectFunc<&similar_to_escape_2>, true, false, TArgs_similar_to_escape_2_Policy>({}); }
+struct TArgs_text_char_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_timestamptz_trunc_zone() { return &GenericExec<TPgDirectFunc<&timestamptz_trunc_zone>, true, true, TArgs_timestamptz_trunc_zone_Policy>; }
-struct TArgs_timestamptz_zone_Policy {
+TExecFunc arrow_text_char() { return TGenericExec<TPgDirectFunc<&text_char>, true, true, TArgs_text_char_Policy>({}); }
+struct TArgs_texticlike_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timestamptz_zone() { return &GenericExec<TPgDirectFunc<&timestamptz_zone>, true, true, TArgs_timestamptz_zone_Policy>; }
-struct TArgs_timestamptztypmodin_Policy {
+TExecFunc arrow_texticlike() { return TGenericExec<TPgDirectFunc<&texticlike>, true, true, TArgs_texticlike_Policy>({}); }
+struct TArgs_texticnlike_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timestamptztypmodin() { return &GenericExec<TPgDirectFunc<&timestamptztypmodin>, true, true, TArgs_timestamptztypmodin_Policy>; }
-struct TArgs_timestamptztypmodout_Policy {
+TExecFunc arrow_texticnlike() { return TGenericExec<TPgDirectFunc<&texticnlike>, true, true, TArgs_texticnlike_Policy>({}); }
+struct TArgs_texticregexeq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timestamptztypmodout() { return &GenericExec<TPgDirectFunc<&timestamptztypmodout>, true, false, TArgs_timestamptztypmodout_Policy>; }
-struct TArgs_to_ascii_default_Policy {
+TExecFunc arrow_texticregexeq() { return TGenericExec<TPgDirectFunc<&texticregexeq>, true, true, TArgs_texticregexeq_Policy>({}); }
+struct TArgs_texticregexne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_to_ascii_default() { return &GenericExec<TPgDirectFunc<&to_ascii_default>, true, false, TArgs_to_ascii_default_Policy>; }
-struct TArgs_to_ascii_enc_Policy {
+TExecFunc arrow_texticregexne() { return TGenericExec<TPgDirectFunc<&texticregexne>, true, true, TArgs_texticregexne_Policy>({}); }
+struct TArgs_textlike_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_to_ascii_enc() { return &GenericExec<TPgDirectFunc<&to_ascii_enc>, true, false, TArgs_to_ascii_enc_Policy>; }
-struct TArgs_to_ascii_encname_Policy {
+TExecFunc arrow_textlike() { return TGenericExec<TPgDirectFunc<&textlike>, true, true, TArgs_textlike_Policy>({}); }
+struct TArgs_textnlike_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_to_ascii_encname() { return &GenericExec<TPgDirectFunc<&to_ascii_encname>, true, false, TArgs_to_ascii_encname_Policy>; }
-struct TArgs_to_tsquery_Policy {
+TExecFunc arrow_textnlike() { return TGenericExec<TPgDirectFunc<&textnlike>, true, true, TArgs_textnlike_Policy>({}); }
+struct TArgs_textregexeq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_to_tsquery() { return &GenericExec<TPgDirectFunc<&to_tsquery>, true, false, TArgs_to_tsquery_Policy>; }
-struct TArgs_to_tsquery_byid_Policy {
+TExecFunc arrow_textregexeq() { return TGenericExec<TPgDirectFunc<&textregexeq>, true, true, TArgs_textregexeq_Policy>({}); }
+struct TArgs_textregexne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_to_tsquery_byid() { return &GenericExec<TPgDirectFunc<&to_tsquery_byid>, true, false, TArgs_to_tsquery_byid_Policy>; }
-struct TArgs_to_tsvector_Policy {
+TExecFunc arrow_textregexne() { return TGenericExec<TPgDirectFunc<&textregexne>, true, true, TArgs_textregexne_Policy>({}); }
+struct TArgs_textregexreplace_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,false};
 };
-TExecFunc arrow_to_tsvector() { return &GenericExec<TPgDirectFunc<&to_tsvector>, true, false, TArgs_to_tsvector_Policy>; }
-struct TArgs_to_tsvector_byid_Policy {
+TExecFunc arrow_textregexreplace() { return TGenericExec<TPgDirectFunc<&textregexreplace>, true, false, TArgs_textregexreplace_Policy>({}); }
+struct TArgs_textregexreplace_noopt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
 };
-TExecFunc arrow_to_tsvector_byid() { return &GenericExec<TPgDirectFunc<&to_tsvector_byid>, true, false, TArgs_to_tsvector_byid_Policy>; }
-struct TArgs_trigger_in_Policy {
+TExecFunc arrow_textregexreplace_noopt() { return TGenericExec<TPgDirectFunc<&textregexreplace_noopt>, true, false, TArgs_textregexreplace_noopt_Policy>({}); }
+struct TArgs_textregexsubstr_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_trigger_in() { return &GenericExec<TPgDirectFunc<&trigger_in>, false, true, TArgs_trigger_in_Policy>; }
-struct TArgs_trigger_out_Policy {
+TExecFunc arrow_textregexsubstr() { return TGenericExec<TPgDirectFunc<&textregexsubstr>, true, false, TArgs_textregexsubstr_Policy>({}); }
+struct TArgs_to_json_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_trigger_out() { return &GenericExec<TPgDirectFunc<&trigger_out>, true, false, TArgs_trigger_out_Policy>; }
-struct TArgs_ts_lexize_Policy {
+TExecFunc arrow_to_json() { return TGenericExec<TPgDirectFunc<&to_json>, true, false, TArgs_to_json_Policy>({}); }
+struct TArgs_to_jsonb_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
-};
-TExecFunc arrow_ts_lexize() { return &GenericExec<TPgDirectFunc<&ts_lexize>, true, false, TArgs_ts_lexize_Policy>; }
-struct TArgs_tsm_handler_in_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_tsm_handler_in() { return &GenericExec<TPgDirectFunc<&tsm_handler_in>, false, true, TArgs_tsm_handler_in_Policy>; }
-struct TArgs_tsm_handler_out_Policy {
+TExecFunc arrow_to_jsonb() { return TGenericExec<TPgDirectFunc<&to_jsonb>, true, false, TArgs_to_jsonb_Policy>({}); }
+struct TArgs_translate_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
 };
-TExecFunc arrow_tsm_handler_out() { return &GenericExec<TPgDirectFunc<&tsm_handler_out>, true, false, TArgs_tsm_handler_out_Policy>; }
+TExecFunc arrow_translate() { return TGenericExec<TPgDirectFunc<&translate>, true, false, TArgs_translate_Policy>({}); }
 struct TArgs_tsqueryin_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_tsqueryin() { return &GenericExec<TPgDirectFunc<&tsqueryin>, true, false, TArgs_tsqueryin_Policy>; }
+TExecFunc arrow_tsqueryin() { return TGenericExec<TPgDirectFunc<&tsqueryin>, true, false, TArgs_tsqueryin_Policy>({}); }
 struct TArgs_tsqueryout_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_tsqueryout() { return &GenericExec<TPgDirectFunc<&tsqueryout>, true, false, TArgs_tsqueryout_Policy>; }
+TExecFunc arrow_tsqueryout() { return TGenericExec<TPgDirectFunc<&tsqueryout>, true, false, TArgs_tsqueryout_Policy>({}); }
 struct TArgs_tsqueryrecv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_tsqueryrecv() { return &GenericExec<TPgDirectFunc<&tsqueryrecv>, true, false, TArgs_tsqueryrecv_Policy>; }
+TExecFunc arrow_tsqueryrecv() { return TGenericExec<TPgDirectFunc<&tsqueryrecv>, true, false, TArgs_tsqueryrecv_Policy>({}); }
 struct TArgs_tsquerysend_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_tsquerysend() { return &GenericExec<TPgDirectFunc<&tsquerysend>, true, false, TArgs_tsquerysend_Policy>; }
+TExecFunc arrow_tsquerysend() { return TGenericExec<TPgDirectFunc<&tsquerysend>, true, false, TArgs_tsquerysend_Policy>({}); }
 struct TArgs_tsquerytree_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_tsquerytree() { return &GenericExec<TPgDirectFunc<&tsquerytree>, true, false, TArgs_tsquerytree_Policy>; }
-struct TArgs_varbit_Policy {
+TExecFunc arrow_tsquerytree() { return TGenericExec<TPgDirectFunc<&tsquerytree>, true, false, TArgs_tsquerytree_Policy>({}); }
+struct TArgs_tsrange_subdiff_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_varbit() { return &GenericExec<TPgDirectFunc<&varbit>, true, false, TArgs_varbit_Policy>; }
-struct TArgs_varbit_in_Policy {
+TExecFunc arrow_tsrange_subdiff() { return TGenericExec<TPgDirectFunc<&tsrange_subdiff>, true, true, TArgs_tsrange_subdiff_Policy>({}); }
+struct TArgs_tstzrange_subdiff_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_varbit_in() { return &GenericExec<TPgDirectFunc<&varbit_in>, true, false, TArgs_varbit_in_Policy>; }
-struct TArgs_varbit_out_Policy {
+TExecFunc arrow_tstzrange_subdiff() { return TGenericExec<TPgDirectFunc<&tstzrange_subdiff>, true, true, TArgs_tstzrange_subdiff_Policy>({}); }
+struct TArgs_upper_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_varbit_out() { return &GenericExec<TPgDirectFunc<&varbit_out>, true, false, TArgs_varbit_out_Policy>; }
-struct TArgs_varbit_recv_Policy {
+TExecFunc arrow_upper() { return TGenericExec<TPgDirectFunc<&upper>, true, false, TArgs_upper_Policy>({}); }
+struct TArgs_uuid_cmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_varbit_recv() { return &GenericExec<TPgDirectFunc<&varbit_recv>, true, false, TArgs_varbit_recv_Policy>; }
-struct TArgs_varbit_send_Policy {
+TExecFunc arrow_uuid_cmp() { return TGenericExec<TPgDirectFunc<&uuid_cmp>, true, true, TArgs_uuid_cmp_Policy>({}); }
+struct TArgs_uuid_eq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_varbit_send() { return &GenericExec<TPgDirectFunc<&varbit_send>, true, false, TArgs_varbit_send_Policy>; }
-struct TArgs_varbit_support_Policy {
+TExecFunc arrow_uuid_eq() { return TGenericExec<TPgDirectFunc<&uuid_eq>, true, true, TArgs_uuid_eq_Policy>({}); }
+struct TArgs_uuid_ge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_uuid_ge() { return TGenericExec<TPgDirectFunc<&uuid_ge>, true, true, TArgs_uuid_ge_Policy>({}); }
+struct TArgs_uuid_gt_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_varbit_support() { return &GenericExec<TPgDirectFunc<&varbit_support>, true, true, TArgs_varbit_support_Policy>; }
-struct TArgs_varbittypmodin_Policy {
+TExecFunc arrow_uuid_gt() { return TGenericExec<TPgDirectFunc<&uuid_gt>, true, true, TArgs_uuid_gt_Policy>({}); }
+struct TArgs_uuid_hash_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_varbittypmodin() { return &GenericExec<TPgDirectFunc<&varbittypmodin>, true, true, TArgs_varbittypmodin_Policy>; }
-struct TArgs_varbittypmodout_Policy {
+TExecFunc arrow_uuid_hash() { return TGenericExec<TPgDirectFunc<&uuid_hash>, true, true, TArgs_uuid_hash_Policy>({}); }
+struct TArgs_uuid_hash_extended_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_varbittypmodout() { return &GenericExec<TPgDirectFunc<&varbittypmodout>, true, false, TArgs_varbittypmodout_Policy>; }
-struct TArgs_void_in_Policy {
+TExecFunc arrow_uuid_hash_extended() { return TGenericExec<TPgDirectFunc<&uuid_hash_extended>, true, true, TArgs_uuid_hash_extended_Policy>({}); }
+struct TArgs_uuid_in_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_void_in() { return &GenericExec<TPgDirectFunc<&void_in>, true, true, TArgs_void_in_Policy>; }
-struct TArgs_void_out_Policy {
+TExecFunc arrow_uuid_in() { return TGenericExec<TPgDirectFunc<&uuid_in>, true, false, TArgs_uuid_in_Policy>({}); }
+struct TArgs_uuid_le_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_void_out() { return &GenericExec<TPgDirectFunc<&void_out>, true, false, TArgs_void_out_Policy>; }
-struct TArgs_void_recv_Policy {
+TExecFunc arrow_uuid_le() { return TGenericExec<TPgDirectFunc<&uuid_le>, true, true, TArgs_uuid_le_Policy>({}); }
+struct TArgs_uuid_lt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_void_recv() { return &GenericExec<TPgDirectFunc<&void_recv>, true, true, TArgs_void_recv_Policy>; }
-struct TArgs_void_send_Policy {
+TExecFunc arrow_uuid_lt() { return TGenericExec<TPgDirectFunc<&uuid_lt>, true, true, TArgs_uuid_lt_Policy>({}); }
+struct TArgs_uuid_ne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_void_send() { return &GenericExec<TPgDirectFunc<&void_send>, true, false, TArgs_void_send_Policy>; }
-struct TArgs_websearch_to_tsquery_Policy {
+TExecFunc arrow_uuid_ne() { return TGenericExec<TPgDirectFunc<&uuid_ne>, true, true, TArgs_uuid_ne_Policy>({}); }
+struct TArgs_uuid_out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_websearch_to_tsquery() { return &GenericExec<TPgDirectFunc<&websearch_to_tsquery>, true, false, TArgs_websearch_to_tsquery_Policy>; }
-struct TArgs_websearch_to_tsquery_byid_Policy {
+TExecFunc arrow_uuid_out() { return TGenericExec<TPgDirectFunc<&uuid_out>, true, false, TArgs_uuid_out_Policy>({}); }
+struct TArgs_uuid_recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_websearch_to_tsquery_byid() { return &GenericExec<TPgDirectFunc<&websearch_to_tsquery_byid>, true, false, TArgs_websearch_to_tsquery_byid_Policy>; }
-struct TArgs_width_bucket_numeric_Policy {
+TExecFunc arrow_uuid_recv() { return TGenericExec<TPgDirectFunc<&uuid_recv>, true, false, TArgs_uuid_recv_Policy>({}); }
+struct TArgs_uuid_send_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_uuid_send() { return TGenericExec<TPgDirectFunc<&uuid_send>, true, false, TArgs_uuid_send_Policy>({}); }
+struct TArgs_uuid_sortsupport_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_width_bucket_numeric() { return &GenericExec<TPgDirectFunc<&width_bucket_numeric>, true, true, TArgs_width_bucket_numeric_Policy>; }
+TExecFunc arrow_uuid_sortsupport() { return TGenericExec<TPgDirectFunc<&uuid_sortsupport>, true, true, TArgs_uuid_sortsupport_Policy>({}); }
diff --git a/ydb/library/yql/parser/pg_wrapper/pg_kernels.1.cpp b/ydb/library/yql/parser/pg_wrapper/pg_kernels.1.cpp
index ca129332963..0bc21caeab9 100644
--- a/ydb/library/yql/parser/pg_wrapper/pg_kernels.1.cpp
+++ b/ydb/library/yql/parser/pg_wrapper/pg_kernels.1.cpp
@@ -28,7 +28,11 @@ namespace NYql {
 
 extern "C" {
 
+#ifdef USE_SLOW_PG_KERNELS
+#include "pg_kernels.slow.1.inc"
+#else
 #include "pg_kernels.1.inc"
+#endif
 
 }
 
diff --git a/ydb/library/yql/parser/pg_wrapper/pg_kernels.1.inc b/ydb/library/yql/parser/pg_wrapper/pg_kernels.1.inc
index a4399ec7dd6..4973eb6205b 100644
--- a/ydb/library/yql/parser/pg_wrapper/pg_kernels.1.inc
+++ b/ydb/library/yql/parser/pg_wrapper/pg_kernels.1.inc
@@ -1,2952 +1,3685 @@
-struct TArgs_areajoinsel_Policy {
+struct TArgs_aclcontains_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_areajoinsel() { return &GenericExec<TPgDirectFunc<&areajoinsel>, true, true, TArgs_areajoinsel_Policy>; }
-struct TArgs_areasel_Policy {
+TExecFunc arrow_aclcontains() { return TGenericExec<TPgDirectFunc<&aclcontains>, true, true, TArgs_aclcontains_Policy>({}); }
+struct TArgs_acldefault_sql_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+};
+TExecFunc arrow_acldefault_sql() { return TGenericExec<TPgDirectFunc<&acldefault_sql>, true, false, TArgs_acldefault_sql_Policy>({}); }
+struct TArgs_aclinsert_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_aclinsert() { return TGenericExec<TPgDirectFunc<&aclinsert>, true, false, TArgs_aclinsert_Policy>({}); }
+struct TArgs_aclitem_eq_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_areasel() { return &GenericExec<TPgDirectFunc<&areasel>, true, true, TArgs_areasel_Policy>; }
-struct TArgs_array_typanalyze_Policy {
+TExecFunc arrow_aclitem_eq() { return TGenericExec<TPgDirectFunc<&aclitem_eq>, true, true, TArgs_aclitem_eq_Policy>({}); }
+struct TArgs_aclitemin_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_aclitemin() { return TGenericExec<TPgDirectFunc<&aclitemin>, true, false, TArgs_aclitemin_Policy>({}); }
+struct TArgs_aclitemout_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_aclitemout() { return TGenericExec<TPgDirectFunc<&aclitemout>, true, false, TArgs_aclitemout_Policy>({}); }
+struct TArgs_aclremove_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_aclremove() { return TGenericExec<TPgDirectFunc<&aclremove>, true, false, TArgs_aclremove_Policy>({}); }
+struct TArgs_amvalidate_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_array_typanalyze() { return &GenericExec<TPgDirectFunc<&array_typanalyze>, true, true, TArgs_array_typanalyze_Policy>; }
-struct TArgs_arraycontjoinsel_Policy {
+TExecFunc arrow_amvalidate() { return TGenericExec<TPgDirectFunc<&amvalidate>, true, true, TArgs_amvalidate_Policy>({}); }
+struct TArgs_array_cardinality_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_arraycontjoinsel() { return &GenericExec<TPgDirectFunc<&arraycontjoinsel>, true, true, TArgs_arraycontjoinsel_Policy>; }
-struct TArgs_arraycontsel_Policy {
+TExecFunc arrow_array_cardinality() { return TGenericExec<TPgDirectFunc<&array_cardinality>, true, true, TArgs_array_cardinality_Policy>({}); }
+struct TArgs_array_dims_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_array_dims() { return TGenericExec<TPgDirectFunc<&array_dims>, true, false, TArgs_array_dims_Policy>({}); }
+struct TArgs_array_eq_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_array_eq() { return TGenericExec<TPgDirectFunc<&array_eq>, true, true, TArgs_array_eq_Policy>({}); }
+struct TArgs_array_fill_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+};
+TExecFunc arrow_array_fill() { return TGenericExec<TPgDirectFunc<&array_fill>, false, false, TArgs_array_fill_Policy>({}); }
+struct TArgs_array_fill_with_lower_bounds_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
+};
+TExecFunc arrow_array_fill_with_lower_bounds() { return TGenericExec<TPgDirectFunc<&array_fill_with_lower_bounds>, false, false, TArgs_array_fill_with_lower_bounds_Policy>({}); }
+struct TArgs_array_ge_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_array_ge() { return TGenericExec<TPgDirectFunc<&array_ge>, true, true, TArgs_array_ge_Policy>({}); }
+struct TArgs_array_gt_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_array_gt() { return TGenericExec<TPgDirectFunc<&array_gt>, true, true, TArgs_array_gt_Policy>({}); }
+struct TArgs_array_in_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+};
+TExecFunc arrow_array_in() { return TGenericExec<TPgDirectFunc<&array_in>, true, false, TArgs_array_in_Policy>({}); }
+struct TArgs_array_larger_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_array_larger() { return TGenericExec<TPgDirectFunc<&array_larger>, true, false, TArgs_array_larger_Policy>({}); }
+struct TArgs_array_le_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_array_le() { return TGenericExec<TPgDirectFunc<&array_le>, true, true, TArgs_array_le_Policy>({}); }
+struct TArgs_array_length_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+};
+TExecFunc arrow_array_length() { return TGenericExec<TPgDirectFunc<&array_length>, true, true, TArgs_array_length_Policy>({}); }
+struct TArgs_array_lower_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+};
+TExecFunc arrow_array_lower() { return TGenericExec<TPgDirectFunc<&array_lower>, true, true, TArgs_array_lower_Policy>({}); }
+struct TArgs_array_lt_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_array_lt() { return TGenericExec<TPgDirectFunc<&array_lt>, true, true, TArgs_array_lt_Policy>({}); }
+struct TArgs_array_ndims_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_array_ndims() { return TGenericExec<TPgDirectFunc<&array_ndims>, true, true, TArgs_array_ndims_Policy>({}); }
+struct TArgs_array_ne_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_array_ne() { return TGenericExec<TPgDirectFunc<&array_ne>, true, true, TArgs_array_ne_Policy>({}); }
+struct TArgs_array_out_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_array_out() { return TGenericExec<TPgDirectFunc<&array_out>, true, false, TArgs_array_out_Policy>({}); }
+struct TArgs_array_recv_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
+};
+TExecFunc arrow_array_recv() { return TGenericExec<TPgDirectFunc<&array_recv>, true, false, TArgs_array_recv_Policy>({}); }
+struct TArgs_array_remove_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+};
+TExecFunc arrow_array_remove() { return TGenericExec<TPgDirectFunc<&array_remove>, false, false, TArgs_array_remove_Policy>({}); }
+struct TArgs_array_replace_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+};
+TExecFunc arrow_array_replace() { return TGenericExec<TPgDirectFunc<&array_replace>, false, false, TArgs_array_replace_Policy>({}); }
+struct TArgs_array_send_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_array_send() { return TGenericExec<TPgDirectFunc<&array_send>, true, false, TArgs_array_send_Policy>({}); }
+struct TArgs_array_smaller_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_arraycontsel() { return &GenericExec<TPgDirectFunc<&arraycontsel>, true, true, TArgs_arraycontsel_Policy>; }
-struct TArgs_brin_minmax_add_value_Policy {
+TExecFunc arrow_array_smaller() { return TGenericExec<TPgDirectFunc<&array_smaller>, true, false, TArgs_array_smaller_Policy>({}); }
+struct TArgs_array_to_text_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_array_to_text() { return TGenericExec<TPgDirectFunc<&array_to_text>, true, false, TArgs_array_to_text_Policy>({}); }
+struct TArgs_array_to_text_null_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+};
+TExecFunc arrow_array_to_text_null() { return TGenericExec<TPgDirectFunc<&array_to_text_null>, false, false, TArgs_array_to_text_null_Policy>({}); }
+struct TArgs_array_to_tsvector_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_array_to_tsvector() { return TGenericExec<TPgDirectFunc<&array_to_tsvector>, true, false, TArgs_array_to_tsvector_Policy>({}); }
+struct TArgs_array_unnest_support_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_array_unnest_support() { return TGenericExec<TPgDirectFunc<&array_unnest_support>, true, true, TArgs_array_unnest_support_Policy>({}); }
+struct TArgs_array_upper_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+};
+TExecFunc arrow_array_upper() { return TGenericExec<TPgDirectFunc<&array_upper>, true, true, TArgs_array_upper_Policy>({}); }
+struct TArgs_arraycontained_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_arraycontained() { return TGenericExec<TPgDirectFunc<&arraycontained>, true, true, TArgs_arraycontained_Policy>({}); }
+struct TArgs_arraycontains_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_arraycontains() { return TGenericExec<TPgDirectFunc<&arraycontains>, true, true, TArgs_arraycontains_Policy>({}); }
+struct TArgs_arrayoverlap_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_arrayoverlap() { return TGenericExec<TPgDirectFunc<&arrayoverlap>, true, true, TArgs_arrayoverlap_Policy>({}); }
+struct TArgs_binary_upgrade_create_empty_extension_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 7> IsFixedArg = {false,false,true,false,false,false,false};
+};
+TExecFunc arrow_binary_upgrade_create_empty_extension() { return TGenericExec<TPgDirectFunc<&binary_upgrade_create_empty_extension>, false, true, TArgs_binary_upgrade_create_empty_extension_Policy>({}); }
+struct TArgs_binary_upgrade_set_missing_value_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
+};
+TExecFunc arrow_binary_upgrade_set_missing_value() { return TGenericExec<TPgDirectFunc<&binary_upgrade_set_missing_value>, true, true, TArgs_binary_upgrade_set_missing_value_Policy>({}); }
+struct TArgs_binary_upgrade_set_next_array_pg_type_oid_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_binary_upgrade_set_next_array_pg_type_oid() { return TGenericExec<TPgDirectFunc<&binary_upgrade_set_next_array_pg_type_oid>, true, true, TArgs_binary_upgrade_set_next_array_pg_type_oid_Policy>({}); }
+struct TArgs_binary_upgrade_set_next_heap_pg_class_oid_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_binary_upgrade_set_next_heap_pg_class_oid() { return TGenericExec<TPgDirectFunc<&binary_upgrade_set_next_heap_pg_class_oid>, true, true, TArgs_binary_upgrade_set_next_heap_pg_class_oid_Policy>({}); }
+struct TArgs_binary_upgrade_set_next_index_pg_class_oid_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_binary_upgrade_set_next_index_pg_class_oid() { return TGenericExec<TPgDirectFunc<&binary_upgrade_set_next_index_pg_class_oid>, true, true, TArgs_binary_upgrade_set_next_index_pg_class_oid_Policy>({}); }
+struct TArgs_binary_upgrade_set_next_multirange_array_pg_type_oid_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_binary_upgrade_set_next_multirange_array_pg_type_oid() { return TGenericExec<TPgDirectFunc<&binary_upgrade_set_next_multirange_array_pg_type_oid>, true, true, TArgs_binary_upgrade_set_next_multirange_array_pg_type_oid_Policy>({}); }
+struct TArgs_binary_upgrade_set_next_multirange_pg_type_oid_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_binary_upgrade_set_next_multirange_pg_type_oid() { return TGenericExec<TPgDirectFunc<&binary_upgrade_set_next_multirange_pg_type_oid>, true, true, TArgs_binary_upgrade_set_next_multirange_pg_type_oid_Policy>({}); }
+struct TArgs_binary_upgrade_set_next_pg_authid_oid_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_binary_upgrade_set_next_pg_authid_oid() { return TGenericExec<TPgDirectFunc<&binary_upgrade_set_next_pg_authid_oid>, true, true, TArgs_binary_upgrade_set_next_pg_authid_oid_Policy>({}); }
+struct TArgs_binary_upgrade_set_next_pg_enum_oid_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_binary_upgrade_set_next_pg_enum_oid() { return TGenericExec<TPgDirectFunc<&binary_upgrade_set_next_pg_enum_oid>, true, true, TArgs_binary_upgrade_set_next_pg_enum_oid_Policy>({}); }
+struct TArgs_binary_upgrade_set_next_pg_type_oid_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_binary_upgrade_set_next_pg_type_oid() { return TGenericExec<TPgDirectFunc<&binary_upgrade_set_next_pg_type_oid>, true, true, TArgs_binary_upgrade_set_next_pg_type_oid_Policy>({}); }
+struct TArgs_binary_upgrade_set_next_toast_pg_class_oid_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_binary_upgrade_set_next_toast_pg_class_oid() { return TGenericExec<TPgDirectFunc<&binary_upgrade_set_next_toast_pg_class_oid>, true, true, TArgs_binary_upgrade_set_next_toast_pg_class_oid_Policy>({}); }
+struct TArgs_binary_upgrade_set_record_init_privs_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_binary_upgrade_set_record_init_privs() { return TGenericExec<TPgDirectFunc<&binary_upgrade_set_record_init_privs>, true, true, TArgs_binary_upgrade_set_record_init_privs_Policy>({}); }
+struct TArgs_bool_int4_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_bool_int4() { return TGenericExec<TPgDirectFunc<&bool_int4>, true, true, TArgs_bool_int4_Policy>({}); }
+struct TArgs_brin_inclusion_add_value_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_brin_minmax_add_value() { return &GenericExec<TPgDirectFunc<&brin_minmax_add_value>, true, true, TArgs_brin_minmax_add_value_Policy>; }
-struct TArgs_brin_minmax_consistent_Policy {
+TExecFunc arrow_brin_inclusion_add_value() { return TGenericExec<TPgDirectFunc<&brin_inclusion_add_value>, true, true, TArgs_brin_inclusion_add_value_Policy>({}); }
+struct TArgs_brin_inclusion_consistent_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_brin_minmax_consistent() { return &GenericExec<TPgDirectFunc<&brin_minmax_consistent>, true, true, TArgs_brin_minmax_consistent_Policy>; }
-struct TArgs_brin_minmax_opcinfo_Policy {
+TExecFunc arrow_brin_inclusion_consistent() { return TGenericExec<TPgDirectFunc<&brin_inclusion_consistent>, true, true, TArgs_brin_inclusion_consistent_Policy>({}); }
+struct TArgs_brin_inclusion_opcinfo_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_brin_minmax_opcinfo() { return &GenericExec<TPgDirectFunc<&brin_minmax_opcinfo>, true, true, TArgs_brin_minmax_opcinfo_Policy>; }
-struct TArgs_brin_minmax_union_Policy {
+TExecFunc arrow_brin_inclusion_opcinfo() { return TGenericExec<TPgDirectFunc<&brin_inclusion_opcinfo>, true, true, TArgs_brin_inclusion_opcinfo_Policy>({}); }
+struct TArgs_brin_inclusion_union_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_brin_minmax_union() { return &GenericExec<TPgDirectFunc<&brin_minmax_union>, true, true, TArgs_brin_minmax_union_Policy>; }
-struct TArgs_btnamecmp_Policy {
+TExecFunc arrow_brin_inclusion_union() { return TGenericExec<TPgDirectFunc<&brin_inclusion_union>, true, true, TArgs_brin_inclusion_union_Policy>({}); }
+struct TArgs_btarraycmp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_btnamecmp() { return &GenericExec<TPgDirectFunc<&btnamecmp>, true, true, TArgs_btnamecmp_Policy>; }
-struct TArgs_btnamesortsupport_Policy {
+TExecFunc arrow_btarraycmp() { return TGenericExec<TPgDirectFunc<&btarraycmp>, true, true, TArgs_btarraycmp_Policy>({}); }
+struct TArgs_btequalimage_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_btequalimage() { return TGenericExec<TPgDirectFunc<&btequalimage>, true, true, TArgs_btequalimage_Policy>({}); }
+struct TArgs_bthandler_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_btnamesortsupport() { return &GenericExec<TPgDirectFunc<&btnamesortsupport>, true, true, TArgs_btnamesortsupport_Policy>; }
-struct TArgs_btrecordcmp_Policy {
+TExecFunc arrow_bthandler() { return TGenericExec<TPgDirectFunc<&bthandler>, true, true, TArgs_bthandler_Policy>({}); }
+struct TArgs_btnametextcmp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_btrecordcmp() { return &GenericExec<TPgDirectFunc<&btrecordcmp>, true, true, TArgs_btrecordcmp_Policy>; }
-struct TArgs_btrecordimagecmp_Policy {
+TExecFunc arrow_btnametextcmp() { return TGenericExec<TPgDirectFunc<&btnametextcmp>, true, true, TArgs_btnametextcmp_Policy>({}); }
+struct TArgs_bttext_pattern_cmp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_btrecordimagecmp() { return &GenericExec<TPgDirectFunc<&btrecordimagecmp>, true, true, TArgs_btrecordimagecmp_Policy>; }
-struct TArgs_bttidcmp_Policy {
+TExecFunc arrow_bttext_pattern_cmp() { return TGenericExec<TPgDirectFunc<&bttext_pattern_cmp>, true, true, TArgs_bttext_pattern_cmp_Policy>({}); }
+struct TArgs_bttext_pattern_sortsupport_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_bttext_pattern_sortsupport() { return TGenericExec<TPgDirectFunc<&bttext_pattern_sortsupport>, true, true, TArgs_bttext_pattern_sortsupport_Policy>({}); }
+struct TArgs_bttextcmp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_bttidcmp() { return &GenericExec<TPgDirectFunc<&bttidcmp>, true, true, TArgs_bttidcmp_Policy>; }
-struct TArgs_cideq_Policy {
+TExecFunc arrow_bttextcmp() { return TGenericExec<TPgDirectFunc<&bttextcmp>, true, true, TArgs_bttextcmp_Policy>({}); }
+struct TArgs_bttextnamecmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_cideq() { return &GenericExec<TPgDirectFunc<&cideq>, true, true, TArgs_cideq_Policy>; }
-struct TArgs_cidin_Policy {
+TExecFunc arrow_bttextnamecmp() { return TGenericExec<TPgDirectFunc<&bttextnamecmp>, true, true, TArgs_bttextnamecmp_Policy>({}); }
+struct TArgs_bttextsortsupport_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_cidin() { return &GenericExec<TPgDirectFunc<&cidin>, true, true, TArgs_cidin_Policy>; }
-struct TArgs_cidout_Policy {
+TExecFunc arrow_bttextsortsupport() { return TGenericExec<TPgDirectFunc<&bttextsortsupport>, true, true, TArgs_bttextsortsupport_Policy>({}); }
+struct TArgs_btvarstrequalimage_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_cidout() { return &GenericExec<TPgDirectFunc<&cidout>, true, false, TArgs_cidout_Policy>; }
-struct TArgs_cidrecv_Policy {
+TExecFunc arrow_btvarstrequalimage() { return TGenericExec<TPgDirectFunc<&btvarstrequalimage>, true, true, TArgs_btvarstrequalimage_Policy>({}); }
+struct TArgs_byteaGetBit_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+};
+TExecFunc arrow_byteaGetBit() { return TGenericExec<TPgDirectFunc<&byteaGetBit>, true, true, TArgs_byteaGetBit_Policy>({}); }
+struct TArgs_byteaGetByte_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+};
+TExecFunc arrow_byteaGetByte() { return TGenericExec<TPgDirectFunc<&byteaGetByte>, true, true, TArgs_byteaGetByte_Policy>({}); }
+struct TArgs_byteaSetBit_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+};
+TExecFunc arrow_byteaSetBit() { return TGenericExec<TPgDirectFunc<&byteaSetBit>, true, false, TArgs_byteaSetBit_Policy>({}); }
+struct TArgs_byteaSetByte_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+};
+TExecFunc arrow_byteaSetByte() { return TGenericExec<TPgDirectFunc<&byteaSetByte>, true, false, TArgs_byteaSetByte_Policy>({}); }
+struct TArgs_bytea_bit_count_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_bytea_bit_count() { return TGenericExec<TPgDirectFunc<&bytea_bit_count>, true, true, TArgs_bytea_bit_count_Policy>({}); }
+struct TArgs_bytea_sortsupport_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_cidrecv() { return &GenericExec<TPgDirectFunc<&cidrecv>, true, true, TArgs_cidrecv_Policy>; }
-struct TArgs_cidsend_Policy {
+TExecFunc arrow_bytea_sortsupport() { return TGenericExec<TPgDirectFunc<&bytea_sortsupport>, true, true, TArgs_bytea_sortsupport_Policy>({}); }
+struct TArgs_bytea_string_agg_finalfn_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_cidsend() { return &GenericExec<TPgDirectFunc<&cidsend>, true, false, TArgs_cidsend_Policy>; }
-struct TArgs_contjoinsel_Policy {
+TExecFunc arrow_bytea_string_agg_finalfn() { return TGenericExec<TPgDirectFunc<&bytea_string_agg_finalfn>, false, false, TArgs_bytea_string_agg_finalfn_Policy>({}); }
+struct TArgs_bytea_string_agg_transfn_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
 };
-TExecFunc arrow_contjoinsel() { return &GenericExec<TPgDirectFunc<&contjoinsel>, true, true, TArgs_contjoinsel_Policy>; }
-struct TArgs_contsel_Policy {
+TExecFunc arrow_bytea_string_agg_transfn() { return TGenericExec<TPgDirectFunc<&bytea_string_agg_transfn>, false, true, TArgs_bytea_string_agg_transfn_Policy>({}); }
+struct TArgs_bytea_substr_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_contsel() { return &GenericExec<TPgDirectFunc<&contsel>, true, true, TArgs_contsel_Policy>; }
-struct TArgs_current_database_Policy {
+TExecFunc arrow_bytea_substr() { return TGenericExec<TPgDirectFunc<&bytea_substr>, true, false, TArgs_bytea_substr_Policy>({}); }
+struct TArgs_bytea_substr_no_len_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_current_database() { return &GenericExec<TPgDirectFunc<&current_database>, true, false, TArgs_current_database_Policy>; }
-struct TArgs_current_query_Policy {
+TExecFunc arrow_bytea_substr_no_len() { return TGenericExec<TPgDirectFunc<&bytea_substr_no_len>, true, false, TArgs_bytea_substr_no_len_Policy>({}); }
+struct TArgs_byteacat_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_current_query() { return &GenericExec<TPgDirectFunc<&current_query>, false, false, TArgs_current_query_Policy>; }
-struct TArgs_current_schema_Policy {
+TExecFunc arrow_byteacat() { return TGenericExec<TPgDirectFunc<&byteacat>, true, false, TArgs_byteacat_Policy>({}); }
+struct TArgs_byteacmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_current_schema() { return &GenericExec<TPgDirectFunc<&current_schema>, true, false, TArgs_current_schema_Policy>; }
-struct TArgs_current_schemas_Policy {
+TExecFunc arrow_byteacmp() { return TGenericExec<TPgDirectFunc<&byteacmp>, true, true, TArgs_byteacmp_Policy>({}); }
+struct TArgs_byteaeq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_current_schemas() { return &GenericExec<TPgDirectFunc<&current_schemas>, true, false, TArgs_current_schemas_Policy>; }
-struct TArgs_current_user_Policy {
+TExecFunc arrow_byteaeq() { return TGenericExec<TPgDirectFunc<&byteaeq>, true, true, TArgs_byteaeq_Policy>({}); }
+struct TArgs_byteage_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_byteage() { return TGenericExec<TPgDirectFunc<&byteage>, true, true, TArgs_byteage_Policy>({}); }
+struct TArgs_byteagt_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_byteagt() { return TGenericExec<TPgDirectFunc<&byteagt>, true, true, TArgs_byteagt_Policy>({}); }
+struct TArgs_byteain_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_byteain() { return TGenericExec<TPgDirectFunc<&byteain>, true, false, TArgs_byteain_Policy>({}); }
+struct TArgs_byteale_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_current_user() { return &GenericExec<TPgDirectFunc<&current_user>, true, false, TArgs_current_user_Policy>; }
-struct TArgs_currtid_byrelname_Policy {
+TExecFunc arrow_byteale() { return TGenericExec<TPgDirectFunc<&byteale>, true, true, TArgs_byteale_Policy>({}); }
+struct TArgs_bytealt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_currtid_byrelname() { return &GenericExec<TPgDirectFunc<&currtid_byrelname>, true, false, TArgs_currtid_byrelname_Policy>; }
-struct TArgs_currval_oid_Policy {
+TExecFunc arrow_bytealt() { return TGenericExec<TPgDirectFunc<&bytealt>, true, true, TArgs_bytealt_Policy>({}); }
+struct TArgs_byteane_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_byteane() { return TGenericExec<TPgDirectFunc<&byteane>, true, true, TArgs_byteane_Policy>({}); }
+struct TArgs_byteaoctetlen_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_byteaoctetlen() { return TGenericExec<TPgDirectFunc<&byteaoctetlen>, true, true, TArgs_byteaoctetlen_Policy>({}); }
+struct TArgs_byteaout_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_byteaout() { return TGenericExec<TPgDirectFunc<&byteaout>, true, false, TArgs_byteaout_Policy>({}); }
+struct TArgs_byteaoverlay_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 4> IsFixedArg = {false,false,true,true};
+};
+TExecFunc arrow_byteaoverlay() { return TGenericExec<TPgDirectFunc<&byteaoverlay>, true, false, TArgs_byteaoverlay_Policy>({}); }
+struct TArgs_byteaoverlay_no_len_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,true};
+};
+TExecFunc arrow_byteaoverlay_no_len() { return TGenericExec<TPgDirectFunc<&byteaoverlay_no_len>, true, false, TArgs_byteaoverlay_no_len_Policy>({}); }
+struct TArgs_byteapos_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_byteapos() { return TGenericExec<TPgDirectFunc<&byteapos>, true, true, TArgs_byteapos_Policy>({}); }
+struct TArgs_bytearecv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_currval_oid() { return &GenericExec<TPgDirectFunc<&currval_oid>, true, true, TArgs_currval_oid_Policy>; }
+TExecFunc arrow_bytearecv() { return TGenericExec<TPgDirectFunc<&bytearecv>, true, false, TArgs_bytearecv_Policy>({}); }
+struct TArgs_byteasend_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_byteasend() { return TGenericExec<TPgDirectFunc<&byteasend>, true, false, TArgs_byteasend_Policy>({}); }
+struct TArgs_cursor_to_xml_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 5> IsFixedArg = {false,true,true,true,false};
+};
+TExecFunc arrow_cursor_to_xml() { return TGenericExec<TPgDirectFunc<&cursor_to_xml>, true, false, TArgs_cursor_to_xml_Policy>({}); }
+struct TArgs_cursor_to_xmlschema_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 4> IsFixedArg = {false,true,true,false};
+};
+TExecFunc arrow_cursor_to_xmlschema() { return TGenericExec<TPgDirectFunc<&cursor_to_xmlschema>, true, false, TArgs_cursor_to_xmlschema_Policy>({}); }
+struct TArgs_database_to_xml_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
+};
+TExecFunc arrow_database_to_xml() { return TGenericExec<TPgDirectFunc<&database_to_xml>, true, false, TArgs_database_to_xml_Policy>({}); }
+struct TArgs_database_to_xml_and_xmlschema_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
+};
+TExecFunc arrow_database_to_xml_and_xmlschema() { return TGenericExec<TPgDirectFunc<&database_to_xml_and_xmlschema>, true, false, TArgs_database_to_xml_and_xmlschema_Policy>({}); }
+struct TArgs_database_to_xmlschema_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
+};
+TExecFunc arrow_database_to_xmlschema() { return TGenericExec<TPgDirectFunc<&database_to_xmlschema>, true, false, TArgs_database_to_xmlschema_Policy>({}); }
 struct TArgs_date_cmp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_date_cmp() { return &GenericExec<TPgDirectFunc<&date_cmp>, true, true, TArgs_date_cmp_Policy>; }
+TExecFunc arrow_date_cmp() { return TGenericExec<TPgDirectFunc<&date_cmp>, true, true, TArgs_date_cmp_Policy>({}); }
 struct TArgs_date_cmp_timestamp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_date_cmp_timestamp() { return &GenericExec<TPgDirectFunc<&date_cmp_timestamp>, true, true, TArgs_date_cmp_timestamp_Policy>; }
+TExecFunc arrow_date_cmp_timestamp() { return TGenericExec<TPgDirectFunc<&date_cmp_timestamp>, true, true, TArgs_date_cmp_timestamp_Policy>({}); }
 struct TArgs_date_cmp_timestamptz_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_date_cmp_timestamptz() { return &GenericExec<TPgDirectFunc<&date_cmp_timestamptz>, true, true, TArgs_date_cmp_timestamptz_Policy>; }
+TExecFunc arrow_date_cmp_timestamptz() { return TGenericExec<TPgDirectFunc<&date_cmp_timestamptz>, true, true, TArgs_date_cmp_timestamptz_Policy>({}); }
 struct TArgs_date_eq_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_date_eq() { return &GenericExec<TPgDirectFunc<&date_eq>, true, true, TArgs_date_eq_Policy>; }
+TExecFunc arrow_date_eq() { return TGenericExec<TPgDirectFunc<&date_eq>, true, true, TArgs_date_eq_Policy>({}); }
 struct TArgs_date_eq_timestamp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_date_eq_timestamp() { return &GenericExec<TPgDirectFunc<&date_eq_timestamp>, true, true, TArgs_date_eq_timestamp_Policy>; }
+TExecFunc arrow_date_eq_timestamp() { return TGenericExec<TPgDirectFunc<&date_eq_timestamp>, true, true, TArgs_date_eq_timestamp_Policy>({}); }
 struct TArgs_date_eq_timestamptz_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_date_eq_timestamptz() { return &GenericExec<TPgDirectFunc<&date_eq_timestamptz>, true, true, TArgs_date_eq_timestamptz_Policy>; }
+TExecFunc arrow_date_eq_timestamptz() { return TGenericExec<TPgDirectFunc<&date_eq_timestamptz>, true, true, TArgs_date_eq_timestamptz_Policy>({}); }
 struct TArgs_date_finite_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_date_finite() { return &GenericExec<TPgDirectFunc<&date_finite>, true, true, TArgs_date_finite_Policy>; }
+TExecFunc arrow_date_finite() { return TGenericExec<TPgDirectFunc<&date_finite>, true, true, TArgs_date_finite_Policy>({}); }
 struct TArgs_date_ge_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_date_ge() { return &GenericExec<TPgDirectFunc<&date_ge>, true, true, TArgs_date_ge_Policy>; }
+TExecFunc arrow_date_ge() { return TGenericExec<TPgDirectFunc<&date_ge>, true, true, TArgs_date_ge_Policy>({}); }
 struct TArgs_date_ge_timestamp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_date_ge_timestamp() { return &GenericExec<TPgDirectFunc<&date_ge_timestamp>, true, true, TArgs_date_ge_timestamp_Policy>; }
+TExecFunc arrow_date_ge_timestamp() { return TGenericExec<TPgDirectFunc<&date_ge_timestamp>, true, true, TArgs_date_ge_timestamp_Policy>({}); }
 struct TArgs_date_ge_timestamptz_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_date_ge_timestamptz() { return &GenericExec<TPgDirectFunc<&date_ge_timestamptz>, true, true, TArgs_date_ge_timestamptz_Policy>; }
+TExecFunc arrow_date_ge_timestamptz() { return TGenericExec<TPgDirectFunc<&date_ge_timestamptz>, true, true, TArgs_date_ge_timestamptz_Policy>({}); }
 struct TArgs_date_gt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_date_gt() { return &GenericExec<TPgDirectFunc<&date_gt>, true, true, TArgs_date_gt_Policy>; }
+TExecFunc arrow_date_gt() { return TGenericExec<TPgDirectFunc<&date_gt>, true, true, TArgs_date_gt_Policy>({}); }
 struct TArgs_date_gt_timestamp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_date_gt_timestamp() { return &GenericExec<TPgDirectFunc<&date_gt_timestamp>, true, true, TArgs_date_gt_timestamp_Policy>; }
+TExecFunc arrow_date_gt_timestamp() { return TGenericExec<TPgDirectFunc<&date_gt_timestamp>, true, true, TArgs_date_gt_timestamp_Policy>({}); }
 struct TArgs_date_gt_timestamptz_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_date_gt_timestamptz() { return &GenericExec<TPgDirectFunc<&date_gt_timestamptz>, true, true, TArgs_date_gt_timestamptz_Policy>; }
+TExecFunc arrow_date_gt_timestamptz() { return TGenericExec<TPgDirectFunc<&date_gt_timestamptz>, true, true, TArgs_date_gt_timestamptz_Policy>({}); }
 struct TArgs_date_in_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_date_in() { return &GenericExec<TPgDirectFunc<&date_in>, true, true, TArgs_date_in_Policy>; }
+TExecFunc arrow_date_in() { return TGenericExec<TPgDirectFunc<&date_in>, true, true, TArgs_date_in_Policy>({}); }
 struct TArgs_date_larger_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_date_larger() { return &GenericExec<TPgDirectFunc<&date_larger>, true, true, TArgs_date_larger_Policy>; }
+TExecFunc arrow_date_larger() { return TGenericExec<TPgDirectFunc<&date_larger>, true, true, TArgs_date_larger_Policy>({}); }
 struct TArgs_date_le_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_date_le() { return &GenericExec<TPgDirectFunc<&date_le>, true, true, TArgs_date_le_Policy>; }
+TExecFunc arrow_date_le() { return TGenericExec<TPgDirectFunc<&date_le>, true, true, TArgs_date_le_Policy>({}); }
 struct TArgs_date_le_timestamp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_date_le_timestamp() { return &GenericExec<TPgDirectFunc<&date_le_timestamp>, true, true, TArgs_date_le_timestamp_Policy>; }
+TExecFunc arrow_date_le_timestamp() { return TGenericExec<TPgDirectFunc<&date_le_timestamp>, true, true, TArgs_date_le_timestamp_Policy>({}); }
 struct TArgs_date_le_timestamptz_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_date_le_timestamptz() { return &GenericExec<TPgDirectFunc<&date_le_timestamptz>, true, true, TArgs_date_le_timestamptz_Policy>; }
+TExecFunc arrow_date_le_timestamptz() { return TGenericExec<TPgDirectFunc<&date_le_timestamptz>, true, true, TArgs_date_le_timestamptz_Policy>({}); }
 struct TArgs_date_lt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_date_lt() { return &GenericExec<TPgDirectFunc<&date_lt>, true, true, TArgs_date_lt_Policy>; }
+TExecFunc arrow_date_lt() { return TGenericExec<TPgDirectFunc<&date_lt>, true, true, TArgs_date_lt_Policy>({}); }
 struct TArgs_date_lt_timestamp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_date_lt_timestamp() { return &GenericExec<TPgDirectFunc<&date_lt_timestamp>, true, true, TArgs_date_lt_timestamp_Policy>; }
+TExecFunc arrow_date_lt_timestamp() { return TGenericExec<TPgDirectFunc<&date_lt_timestamp>, true, true, TArgs_date_lt_timestamp_Policy>({}); }
 struct TArgs_date_lt_timestamptz_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_date_lt_timestamptz() { return &GenericExec<TPgDirectFunc<&date_lt_timestamptz>, true, true, TArgs_date_lt_timestamptz_Policy>; }
+TExecFunc arrow_date_lt_timestamptz() { return TGenericExec<TPgDirectFunc<&date_lt_timestamptz>, true, true, TArgs_date_lt_timestamptz_Policy>({}); }
 struct TArgs_date_mi_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_date_mi() { return &GenericExec<TPgDirectFunc<&date_mi>, true, true, TArgs_date_mi_Policy>; }
+TExecFunc arrow_date_mi() { return TGenericExec<TPgDirectFunc<&date_mi>, true, true, TArgs_date_mi_Policy>({}); }
 struct TArgs_date_mi_interval_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_date_mi_interval() { return &GenericExec<TPgDirectFunc<&date_mi_interval>, true, true, TArgs_date_mi_interval_Policy>; }
+TExecFunc arrow_date_mi_interval() { return TGenericExec<TPgDirectFunc<&date_mi_interval>, true, true, TArgs_date_mi_interval_Policy>({}); }
 struct TArgs_date_mii_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_date_mii() { return &GenericExec<TPgDirectFunc<&date_mii>, true, true, TArgs_date_mii_Policy>; }
+TExecFunc arrow_date_mii() { return TGenericExec<TPgDirectFunc<&date_mii>, true, true, TArgs_date_mii_Policy>({}); }
 struct TArgs_date_ne_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_date_ne() { return &GenericExec<TPgDirectFunc<&date_ne>, true, true, TArgs_date_ne_Policy>; }
+TExecFunc arrow_date_ne() { return TGenericExec<TPgDirectFunc<&date_ne>, true, true, TArgs_date_ne_Policy>({}); }
 struct TArgs_date_ne_timestamp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_date_ne_timestamp() { return &GenericExec<TPgDirectFunc<&date_ne_timestamp>, true, true, TArgs_date_ne_timestamp_Policy>; }
+TExecFunc arrow_date_ne_timestamp() { return TGenericExec<TPgDirectFunc<&date_ne_timestamp>, true, true, TArgs_date_ne_timestamp_Policy>({}); }
 struct TArgs_date_ne_timestamptz_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_date_ne_timestamptz() { return &GenericExec<TPgDirectFunc<&date_ne_timestamptz>, true, true, TArgs_date_ne_timestamptz_Policy>; }
+TExecFunc arrow_date_ne_timestamptz() { return TGenericExec<TPgDirectFunc<&date_ne_timestamptz>, true, true, TArgs_date_ne_timestamptz_Policy>({}); }
 struct TArgs_date_out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_date_out() { return &GenericExec<TPgDirectFunc<&date_out>, true, false, TArgs_date_out_Policy>; }
+TExecFunc arrow_date_out() { return TGenericExec<TPgDirectFunc<&date_out>, true, false, TArgs_date_out_Policy>({}); }
 struct TArgs_date_pl_interval_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_date_pl_interval() { return &GenericExec<TPgDirectFunc<&date_pl_interval>, true, true, TArgs_date_pl_interval_Policy>; }
+TExecFunc arrow_date_pl_interval() { return TGenericExec<TPgDirectFunc<&date_pl_interval>, true, true, TArgs_date_pl_interval_Policy>({}); }
 struct TArgs_date_pli_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_date_pli() { return &GenericExec<TPgDirectFunc<&date_pli>, true, true, TArgs_date_pli_Policy>; }
+TExecFunc arrow_date_pli() { return TGenericExec<TPgDirectFunc<&date_pli>, true, true, TArgs_date_pli_Policy>({}); }
 struct TArgs_date_recv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_date_recv() { return &GenericExec<TPgDirectFunc<&date_recv>, true, true, TArgs_date_recv_Policy>; }
+TExecFunc arrow_date_recv() { return TGenericExec<TPgDirectFunc<&date_recv>, true, true, TArgs_date_recv_Policy>({}); }
 struct TArgs_date_send_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_date_send() { return &GenericExec<TPgDirectFunc<&date_send>, true, false, TArgs_date_send_Policy>; }
+TExecFunc arrow_date_send() { return TGenericExec<TPgDirectFunc<&date_send>, true, false, TArgs_date_send_Policy>({}); }
 struct TArgs_date_smaller_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_date_smaller() { return &GenericExec<TPgDirectFunc<&date_smaller>, true, true, TArgs_date_smaller_Policy>; }
+TExecFunc arrow_date_smaller() { return TGenericExec<TPgDirectFunc<&date_smaller>, true, true, TArgs_date_smaller_Policy>({}); }
 struct TArgs_date_sortsupport_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_date_sortsupport() { return &GenericExec<TPgDirectFunc<&date_sortsupport>, true, true, TArgs_date_sortsupport_Policy>; }
+TExecFunc arrow_date_sortsupport() { return TGenericExec<TPgDirectFunc<&date_sortsupport>, true, true, TArgs_date_sortsupport_Policy>({}); }
 struct TArgs_date_timestamp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_date_timestamp() { return &GenericExec<TPgDirectFunc<&date_timestamp>, true, true, TArgs_date_timestamp_Policy>; }
+TExecFunc arrow_date_timestamp() { return TGenericExec<TPgDirectFunc<&date_timestamp>, true, true, TArgs_date_timestamp_Policy>({}); }
 struct TArgs_date_timestamptz_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_date_timestamptz() { return &GenericExec<TPgDirectFunc<&date_timestamptz>, true, true, TArgs_date_timestamptz_Policy>; }
-struct TArgs_daterange_canonical_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_daterange_canonical() { return &GenericExec<TPgDirectFunc<&daterange_canonical>, true, false, TArgs_daterange_canonical_Policy>; }
-struct TArgs_daterange_subdiff_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
-};
-TExecFunc arrow_daterange_subdiff() { return &GenericExec<TPgDirectFunc<&daterange_subdiff>, true, true, TArgs_daterange_subdiff_Policy>; }
+TExecFunc arrow_date_timestamptz() { return TGenericExec<TPgDirectFunc<&date_timestamptz>, true, true, TArgs_date_timestamptz_Policy>({}); }
 struct TArgs_datetime_timestamp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_datetime_timestamp() { return &GenericExec<TPgDirectFunc<&datetime_timestamp>, true, true, TArgs_datetime_timestamp_Policy>; }
+TExecFunc arrow_datetime_timestamp() { return TGenericExec<TPgDirectFunc<&datetime_timestamp>, true, true, TArgs_datetime_timestamp_Policy>({}); }
 struct TArgs_datetimetz_timestamptz_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_datetimetz_timestamptz() { return &GenericExec<TPgDirectFunc<&datetimetz_timestamptz>, true, true, TArgs_datetimetz_timestamptz_Policy>; }
-struct TArgs_dtoi8_Policy {
+TExecFunc arrow_datetimetz_timestamptz() { return TGenericExec<TPgDirectFunc<&datetimetz_timestamptz>, true, true, TArgs_datetimetz_timestamptz_Policy>({}); }
+struct TArgs_dsimple_init_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_dtoi8() { return &GenericExec<TPgDirectFunc<&dtoi8>, true, true, TArgs_dtoi8_Policy>; }
-struct TArgs_elem_contained_by_range_Policy {
+TExecFunc arrow_dsimple_init() { return TGenericExec<TPgDirectFunc<&dsimple_init>, true, true, TArgs_dsimple_init_Policy>({}); }
+struct TArgs_dsimple_lexize_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_elem_contained_by_range() { return &GenericExec<TPgDirectFunc<&elem_contained_by_range>, true, true, TArgs_elem_contained_by_range_Policy>; }
+TExecFunc arrow_dsimple_lexize() { return TGenericExec<TPgDirectFunc<&dsimple_lexize>, true, true, TArgs_dsimple_lexize_Policy>({}); }
+struct TArgs_dtoi8_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_dtoi8() { return TGenericExec<TPgDirectFunc<&dtoi8>, true, true, TArgs_dtoi8_Policy>({}); }
 struct TArgs_extract_date_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_extract_date() { return &GenericExec<TPgDirectFunc<&extract_date>, true, false, TArgs_extract_date_Policy>; }
+TExecFunc arrow_extract_date() { return TGenericExec<TPgDirectFunc<&extract_date>, true, false, TArgs_extract_date_Policy>({}); }
 struct TArgs_extract_time_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_extract_time() { return &GenericExec<TPgDirectFunc<&extract_time>, true, false, TArgs_extract_time_Policy>; }
+TExecFunc arrow_extract_time() { return TGenericExec<TPgDirectFunc<&extract_time>, true, false, TArgs_extract_time_Policy>({}); }
 struct TArgs_extract_timetz_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_extract_timetz() { return &GenericExec<TPgDirectFunc<&extract_timetz>, true, false, TArgs_extract_timetz_Policy>; }
+TExecFunc arrow_extract_timetz() { return TGenericExec<TPgDirectFunc<&extract_timetz>, true, false, TArgs_extract_timetz_Policy>({}); }
 struct TArgs_ftoi8_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_ftoi8() { return &GenericExec<TPgDirectFunc<&ftoi8>, true, true, TArgs_ftoi8_Policy>; }
-struct TArgs_generate_series_int8_support_Policy {
+TExecFunc arrow_ftoi8() { return TGenericExec<TPgDirectFunc<&ftoi8>, true, true, TArgs_ftoi8_Policy>({}); }
+struct TArgs_generate_series_int4_support_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_generate_series_int8_support() { return &GenericExec<TPgDirectFunc<&generate_series_int8_support>, true, true, TArgs_generate_series_int8_support_Policy>; }
-struct TArgs_gin_clean_pending_list_Policy {
+TExecFunc arrow_generate_series_int4_support() { return TGenericExec<TPgDirectFunc<&generate_series_int4_support>, true, true, TArgs_generate_series_int4_support_Policy>({}); }
+struct TArgs_generate_series_int8_support_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_gin_clean_pending_list() { return &GenericExec<TPgDirectFunc<&gin_clean_pending_list>, true, true, TArgs_gin_clean_pending_list_Policy>; }
+TExecFunc arrow_generate_series_int8_support() { return TGenericExec<TPgDirectFunc<&generate_series_int8_support>, true, true, TArgs_generate_series_int8_support_Policy>({}); }
+struct TArgs_get_current_ts_config_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 0> IsFixedArg = {};
+};
+TExecFunc arrow_get_current_ts_config() { return TGenericExec<TPgDirectFunc<&get_current_ts_config>, true, true, TArgs_get_current_ts_config_Policy>({}); }
+struct TArgs_gin_cmp_prefix_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 4> IsFixedArg = {false,false,true,true};
+};
+TExecFunc arrow_gin_cmp_prefix() { return TGenericExec<TPgDirectFunc<&gin_cmp_prefix>, true, true, TArgs_gin_cmp_prefix_Policy>({}); }
+struct TArgs_gin_cmp_tslexeme_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_gin_cmp_tslexeme() { return TGenericExec<TPgDirectFunc<&gin_cmp_tslexeme>, true, true, TArgs_gin_cmp_tslexeme_Policy>({}); }
 struct TArgs_gin_compare_jsonb_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_gin_compare_jsonb() { return &GenericExec<TPgDirectFunc<&gin_compare_jsonb>, true, true, TArgs_gin_compare_jsonb_Policy>; }
+TExecFunc arrow_gin_compare_jsonb() { return TGenericExec<TPgDirectFunc<&gin_compare_jsonb>, true, true, TArgs_gin_compare_jsonb_Policy>({}); }
 struct TArgs_gin_consistent_jsonb_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 8> IsFixedArg = {true,true,false,true,true,true,true,true};
 };
-TExecFunc arrow_gin_consistent_jsonb() { return &GenericExec<TPgDirectFunc<&gin_consistent_jsonb>, true, true, TArgs_gin_consistent_jsonb_Policy>; }
+TExecFunc arrow_gin_consistent_jsonb() { return TGenericExec<TPgDirectFunc<&gin_consistent_jsonb>, true, true, TArgs_gin_consistent_jsonb_Policy>({}); }
 struct TArgs_gin_consistent_jsonb_path_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 8> IsFixedArg = {true,true,false,true,true,true,true,true};
 };
-TExecFunc arrow_gin_consistent_jsonb_path() { return &GenericExec<TPgDirectFunc<&gin_consistent_jsonb_path>, true, true, TArgs_gin_consistent_jsonb_path_Policy>; }
+TExecFunc arrow_gin_consistent_jsonb_path() { return TGenericExec<TPgDirectFunc<&gin_consistent_jsonb_path>, true, true, TArgs_gin_consistent_jsonb_path_Policy>({}); }
 struct TArgs_gin_extract_jsonb_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_gin_extract_jsonb() { return &GenericExec<TPgDirectFunc<&gin_extract_jsonb>, true, true, TArgs_gin_extract_jsonb_Policy>; }
+TExecFunc arrow_gin_extract_jsonb() { return TGenericExec<TPgDirectFunc<&gin_extract_jsonb>, true, true, TArgs_gin_extract_jsonb_Policy>({}); }
 struct TArgs_gin_extract_jsonb_path_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_gin_extract_jsonb_path() { return &GenericExec<TPgDirectFunc<&gin_extract_jsonb_path>, true, true, TArgs_gin_extract_jsonb_path_Policy>; }
+TExecFunc arrow_gin_extract_jsonb_path() { return TGenericExec<TPgDirectFunc<&gin_extract_jsonb_path>, true, true, TArgs_gin_extract_jsonb_path_Policy>({}); }
 struct TArgs_gin_extract_jsonb_query_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 7> IsFixedArg = {false,true,true,true,true,true,true};
 };
-TExecFunc arrow_gin_extract_jsonb_query() { return &GenericExec<TPgDirectFunc<&gin_extract_jsonb_query>, true, true, TArgs_gin_extract_jsonb_query_Policy>; }
+TExecFunc arrow_gin_extract_jsonb_query() { return TGenericExec<TPgDirectFunc<&gin_extract_jsonb_query>, true, true, TArgs_gin_extract_jsonb_query_Policy>({}); }
 struct TArgs_gin_extract_jsonb_query_path_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 7> IsFixedArg = {false,true,true,true,true,true,true};
 };
-TExecFunc arrow_gin_extract_jsonb_query_path() { return &GenericExec<TPgDirectFunc<&gin_extract_jsonb_query_path>, true, true, TArgs_gin_extract_jsonb_query_path_Policy>; }
+TExecFunc arrow_gin_extract_jsonb_query_path() { return TGenericExec<TPgDirectFunc<&gin_extract_jsonb_query_path>, true, true, TArgs_gin_extract_jsonb_query_path_Policy>({}); }
+struct TArgs_gin_extract_tsquery_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 7> IsFixedArg = {false,true,true,true,true,true,true};
+};
+TExecFunc arrow_gin_extract_tsquery() { return TGenericExec<TPgDirectFunc<&gin_extract_tsquery>, true, true, TArgs_gin_extract_tsquery_Policy>({}); }
+struct TArgs_gin_extract_tsquery_5args_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 5> IsFixedArg = {false,true,true,true,true};
+};
+TExecFunc arrow_gin_extract_tsquery_5args() { return TGenericExec<TPgDirectFunc<&gin_extract_tsquery_5args>, true, true, TArgs_gin_extract_tsquery_5args_Policy>({}); }
+struct TArgs_gin_extract_tsquery_oldsig_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 7> IsFixedArg = {false,true,true,true,true,true,true};
+};
+TExecFunc arrow_gin_extract_tsquery_oldsig() { return TGenericExec<TPgDirectFunc<&gin_extract_tsquery_oldsig>, true, true, TArgs_gin_extract_tsquery_oldsig_Policy>({}); }
+struct TArgs_gin_extract_tsvector_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+};
+TExecFunc arrow_gin_extract_tsvector() { return TGenericExec<TPgDirectFunc<&gin_extract_tsvector>, true, true, TArgs_gin_extract_tsvector_Policy>({}); }
+struct TArgs_gin_extract_tsvector_2args_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+};
+TExecFunc arrow_gin_extract_tsvector_2args() { return TGenericExec<TPgDirectFunc<&gin_extract_tsvector_2args>, true, true, TArgs_gin_extract_tsvector_2args_Policy>({}); }
 struct TArgs_gin_triconsistent_jsonb_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 7> IsFixedArg = {true,true,false,true,true,true,true};
 };
-TExecFunc arrow_gin_triconsistent_jsonb() { return &GenericExec<TPgDirectFunc<&gin_triconsistent_jsonb>, true, true, TArgs_gin_triconsistent_jsonb_Policy>; }
+TExecFunc arrow_gin_triconsistent_jsonb() { return TGenericExec<TPgDirectFunc<&gin_triconsistent_jsonb>, true, true, TArgs_gin_triconsistent_jsonb_Policy>({}); }
 struct TArgs_gin_triconsistent_jsonb_path_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 7> IsFixedArg = {true,true,false,true,true,true,true};
 };
-TExecFunc arrow_gin_triconsistent_jsonb_path() { return &GenericExec<TPgDirectFunc<&gin_triconsistent_jsonb_path>, true, true, TArgs_gin_triconsistent_jsonb_path_Policy>; }
-struct TArgs_gisthandler_Policy {
+TExecFunc arrow_gin_triconsistent_jsonb_path() { return TGenericExec<TPgDirectFunc<&gin_triconsistent_jsonb_path>, true, true, TArgs_gin_triconsistent_jsonb_path_Policy>({}); }
+struct TArgs_gin_tsquery_consistent_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 8> IsFixedArg = {true,true,false,true,true,true,true,true};
+};
+TExecFunc arrow_gin_tsquery_consistent() { return TGenericExec<TPgDirectFunc<&gin_tsquery_consistent>, true, true, TArgs_gin_tsquery_consistent_Policy>({}); }
+struct TArgs_gin_tsquery_consistent_6args_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 6> IsFixedArg = {true,true,false,true,true,true};
+};
+TExecFunc arrow_gin_tsquery_consistent_6args() { return TGenericExec<TPgDirectFunc<&gin_tsquery_consistent_6args>, true, true, TArgs_gin_tsquery_consistent_6args_Policy>({}); }
+struct TArgs_gin_tsquery_consistent_oldsig_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 8> IsFixedArg = {true,true,false,true,true,true,true,true};
 };
-TExecFunc arrow_gisthandler() { return &GenericExec<TPgDirectFunc<&gisthandler>, true, true, TArgs_gisthandler_Policy>; }
+TExecFunc arrow_gin_tsquery_consistent_oldsig() { return TGenericExec<TPgDirectFunc<&gin_tsquery_consistent_oldsig>, true, true, TArgs_gin_tsquery_consistent_oldsig_Policy>({}); }
+struct TArgs_gin_tsquery_triconsistent_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 7> IsFixedArg = {true,true,false,true,true,true,true};
+};
+TExecFunc arrow_gin_tsquery_triconsistent() { return TGenericExec<TPgDirectFunc<&gin_tsquery_triconsistent>, true, true, TArgs_gin_tsquery_triconsistent_Policy>({}); }
 struct TArgs_gtsquery_compress_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_gtsquery_compress() { return &GenericExec<TPgDirectFunc<&gtsquery_compress>, true, true, TArgs_gtsquery_compress_Policy>; }
+TExecFunc arrow_gtsquery_compress() { return TGenericExec<TPgDirectFunc<&gtsquery_compress>, true, true, TArgs_gtsquery_compress_Policy>({}); }
 struct TArgs_gtsquery_consistent_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 5> IsFixedArg = {true,false,true,true,true};
 };
-TExecFunc arrow_gtsquery_consistent() { return &GenericExec<TPgDirectFunc<&gtsquery_consistent>, true, true, TArgs_gtsquery_consistent_Policy>; }
+TExecFunc arrow_gtsquery_consistent() { return TGenericExec<TPgDirectFunc<&gtsquery_consistent>, true, true, TArgs_gtsquery_consistent_Policy>({}); }
 struct TArgs_gtsquery_consistent_oldsig_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
 };
-TExecFunc arrow_gtsquery_consistent_oldsig() { return &GenericExec<TPgDirectFunc<&gtsquery_consistent_oldsig>, true, true, TArgs_gtsquery_consistent_oldsig_Policy>; }
+TExecFunc arrow_gtsquery_consistent_oldsig() { return TGenericExec<TPgDirectFunc<&gtsquery_consistent_oldsig>, true, true, TArgs_gtsquery_consistent_oldsig_Policy>({}); }
 struct TArgs_gtsquery_penalty_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_gtsquery_penalty() { return &GenericExec<TPgDirectFunc<&gtsquery_penalty>, true, true, TArgs_gtsquery_penalty_Policy>; }
+TExecFunc arrow_gtsquery_penalty() { return TGenericExec<TPgDirectFunc<&gtsquery_penalty>, true, true, TArgs_gtsquery_penalty_Policy>({}); }
 struct TArgs_gtsquery_picksplit_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_gtsquery_picksplit() { return &GenericExec<TPgDirectFunc<&gtsquery_picksplit>, true, true, TArgs_gtsquery_picksplit_Policy>; }
+TExecFunc arrow_gtsquery_picksplit() { return TGenericExec<TPgDirectFunc<&gtsquery_picksplit>, true, true, TArgs_gtsquery_picksplit_Policy>({}); }
 struct TArgs_gtsquery_same_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_gtsquery_same() { return &GenericExec<TPgDirectFunc<&gtsquery_same>, true, true, TArgs_gtsquery_same_Policy>; }
+TExecFunc arrow_gtsquery_same() { return TGenericExec<TPgDirectFunc<&gtsquery_same>, true, true, TArgs_gtsquery_same_Policy>({}); }
 struct TArgs_gtsquery_union_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_gtsquery_union() { return &GenericExec<TPgDirectFunc<&gtsquery_union>, true, true, TArgs_gtsquery_union_Policy>; }
-struct TArgs_hash_range_Policy {
+TExecFunc arrow_gtsquery_union() { return TGenericExec<TPgDirectFunc<&gtsquery_union>, true, true, TArgs_gtsquery_union_Policy>({}); }
+struct TArgs_has_any_column_privilege_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_hash_range() { return &GenericExec<TPgDirectFunc<&hash_range>, true, true, TArgs_hash_range_Policy>; }
-struct TArgs_hash_range_extended_Policy {
+TExecFunc arrow_has_any_column_privilege_id() { return TGenericExec<TPgDirectFunc<&has_any_column_privilege_id>, true, true, TArgs_has_any_column_privilege_id_Policy>({}); }
+struct TArgs_has_any_column_privilege_id_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
 };
-TExecFunc arrow_hash_range_extended() { return &GenericExec<TPgDirectFunc<&hash_range_extended>, true, true, TArgs_hash_range_extended_Policy>; }
-struct TArgs_hash_record_Policy {
+TExecFunc arrow_has_any_column_privilege_id_id() { return TGenericExec<TPgDirectFunc<&has_any_column_privilege_id_id>, true, true, TArgs_has_any_column_privilege_id_id_Policy>({}); }
+struct TArgs_has_any_column_privilege_id_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
 };
-TExecFunc arrow_hash_record() { return &GenericExec<TPgDirectFunc<&hash_record>, true, true, TArgs_hash_record_Policy>; }
-struct TArgs_hash_record_extended_Policy {
+TExecFunc arrow_has_any_column_privilege_id_name() { return TGenericExec<TPgDirectFunc<&has_any_column_privilege_id_name>, true, true, TArgs_has_any_column_privilege_id_name_Policy>({}); }
+struct TArgs_has_any_column_privilege_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_hash_record_extended() { return &GenericExec<TPgDirectFunc<&hash_record_extended>, true, true, TArgs_hash_record_extended_Policy>; }
-struct TArgs_hashhandler_Policy {
+TExecFunc arrow_has_any_column_privilege_name() { return TGenericExec<TPgDirectFunc<&has_any_column_privilege_name>, true, true, TArgs_has_any_column_privilege_name_Policy>({}); }
+struct TArgs_has_any_column_privilege_name_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
 };
-TExecFunc arrow_hashhandler() { return &GenericExec<TPgDirectFunc<&hashhandler>, true, true, TArgs_hashhandler_Policy>; }
-struct TArgs_hashmacaddr8_Policy {
+TExecFunc arrow_has_any_column_privilege_name_id() { return TGenericExec<TPgDirectFunc<&has_any_column_privilege_name_id>, true, true, TArgs_has_any_column_privilege_name_id_Policy>({}); }
+struct TArgs_has_any_column_privilege_name_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
 };
-TExecFunc arrow_hashmacaddr8() { return &GenericExec<TPgDirectFunc<&hashmacaddr8>, true, true, TArgs_hashmacaddr8_Policy>; }
-struct TArgs_hashmacaddr8extended_Policy {
+TExecFunc arrow_has_any_column_privilege_name_name() { return TGenericExec<TPgDirectFunc<&has_any_column_privilege_name_name>, true, true, TArgs_has_any_column_privilege_name_name_Policy>({}); }
+struct TArgs_has_column_privilege_id_attnum_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
 };
-TExecFunc arrow_hashmacaddr8extended() { return &GenericExec<TPgDirectFunc<&hashmacaddr8extended>, true, true, TArgs_hashmacaddr8extended_Policy>; }
-struct TArgs_hashtid_Policy {
+TExecFunc arrow_has_column_privilege_id_attnum() { return TGenericExec<TPgDirectFunc<&has_column_privilege_id_attnum>, true, true, TArgs_has_column_privilege_id_attnum_Policy>({}); }
+struct TArgs_has_column_privilege_id_id_attnum_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,false};
 };
-TExecFunc arrow_hashtid() { return &GenericExec<TPgDirectFunc<&hashtid>, true, true, TArgs_hashtid_Policy>; }
-struct TArgs_hashtidextended_Policy {
+TExecFunc arrow_has_column_privilege_id_id_attnum() { return TGenericExec<TPgDirectFunc<&has_column_privilege_id_id_attnum>, true, true, TArgs_has_column_privilege_id_id_attnum_Policy>({}); }
+struct TArgs_has_column_privilege_id_id_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,false,false};
 };
-TExecFunc arrow_hashtidextended() { return &GenericExec<TPgDirectFunc<&hashtidextended>, true, true, TArgs_hashtidextended_Policy>; }
-struct TArgs_i8tod_Policy {
+TExecFunc arrow_has_column_privilege_id_id_name() { return TGenericExec<TPgDirectFunc<&has_column_privilege_id_id_name>, true, true, TArgs_has_column_privilege_id_id_name_Policy>({}); }
+struct TArgs_has_column_privilege_id_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
 };
-TExecFunc arrow_i8tod() { return &GenericExec<TPgDirectFunc<&i8tod>, true, true, TArgs_i8tod_Policy>; }
-struct TArgs_i8tof_Policy {
+TExecFunc arrow_has_column_privilege_id_name() { return TGenericExec<TPgDirectFunc<&has_column_privilege_id_name>, true, true, TArgs_has_column_privilege_id_name_Policy>({}); }
+struct TArgs_has_column_privilege_id_name_attnum_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,false,true,false};
 };
-TExecFunc arrow_i8tof() { return &GenericExec<TPgDirectFunc<&i8tof>, true, true, TArgs_i8tof_Policy>; }
-struct TArgs_i8tooid_Policy {
+TExecFunc arrow_has_column_privilege_id_name_attnum() { return TGenericExec<TPgDirectFunc<&has_column_privilege_id_name_attnum>, true, true, TArgs_has_column_privilege_id_name_attnum_Policy>({}); }
+struct TArgs_has_column_privilege_id_name_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,false,false,false};
 };
-TExecFunc arrow_i8tooid() { return &GenericExec<TPgDirectFunc<&i8tooid>, true, true, TArgs_i8tooid_Policy>; }
-struct TArgs_in_range_date_interval_Policy {
+TExecFunc arrow_has_column_privilege_id_name_name() { return TGenericExec<TPgDirectFunc<&has_column_privilege_id_name_name>, true, true, TArgs_has_column_privilege_id_name_name_Policy>({}); }
+struct TArgs_has_column_privilege_name_attnum_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,false,true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
 };
-TExecFunc arrow_in_range_date_interval() { return &GenericExec<TPgDirectFunc<&in_range_date_interval>, true, true, TArgs_in_range_date_interval_Policy>; }
-struct TArgs_in_range_int8_int8_Policy {
+TExecFunc arrow_has_column_privilege_name_attnum() { return TGenericExec<TPgDirectFunc<&has_column_privilege_name_attnum>, true, true, TArgs_has_column_privilege_name_attnum_Policy>({}); }
+struct TArgs_has_column_privilege_name_id_attnum_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,true,true,false};
 };
-TExecFunc arrow_in_range_int8_int8() { return &GenericExec<TPgDirectFunc<&in_range_int8_int8>, true, true, TArgs_in_range_int8_int8_Policy>; }
-struct TArgs_in_range_time_interval_Policy {
+TExecFunc arrow_has_column_privilege_name_id_attnum() { return TGenericExec<TPgDirectFunc<&has_column_privilege_name_id_attnum>, true, true, TArgs_has_column_privilege_name_id_attnum_Policy>({}); }
+struct TArgs_has_column_privilege_name_id_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,false,true,true};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,true,false,false};
 };
-TExecFunc arrow_in_range_time_interval() { return &GenericExec<TPgDirectFunc<&in_range_time_interval>, true, true, TArgs_in_range_time_interval_Policy>; }
-struct TArgs_in_range_timetz_interval_Policy {
+TExecFunc arrow_has_column_privilege_name_id_name() { return TGenericExec<TPgDirectFunc<&has_column_privilege_name_id_name>, true, true, TArgs_has_column_privilege_name_id_name_Policy>({}); }
+struct TArgs_has_column_privilege_name_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {false,false,false,true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
 };
-TExecFunc arrow_in_range_timetz_interval() { return &GenericExec<TPgDirectFunc<&in_range_timetz_interval>, true, true, TArgs_in_range_timetz_interval_Policy>; }
-struct TArgs_int28_Policy {
+TExecFunc arrow_has_column_privilege_name_name() { return TGenericExec<TPgDirectFunc<&has_column_privilege_name_name>, true, true, TArgs_has_column_privilege_name_name_Policy>({}); }
+struct TArgs_has_column_privilege_name_name_attnum_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,false,true,false};
 };
-TExecFunc arrow_int28() { return &GenericExec<TPgDirectFunc<&int28>, true, true, TArgs_int28_Policy>; }
-struct TArgs_int28div_Policy {
+TExecFunc arrow_has_column_privilege_name_name_attnum() { return TGenericExec<TPgDirectFunc<&has_column_privilege_name_name_attnum>, true, true, TArgs_has_column_privilege_name_name_attnum_Policy>({}); }
+struct TArgs_has_column_privilege_name_name_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,false};
 };
-TExecFunc arrow_int28div() { return &GenericExec<TPgDirectFunc<&int28div>, true, true, TArgs_int28div_Policy>; }
-struct TArgs_int28eq_Policy {
+TExecFunc arrow_has_column_privilege_name_name_name() { return TGenericExec<TPgDirectFunc<&has_column_privilege_name_name_name>, true, true, TArgs_has_column_privilege_name_name_name_Policy>({}); }
+struct TArgs_has_database_privilege_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_int28eq() { return &GenericExec<TPgDirectFunc<&int28eq>, true, true, TArgs_int28eq_Policy>; }
-struct TArgs_int28ge_Policy {
+TExecFunc arrow_has_database_privilege_id() { return TGenericExec<TPgDirectFunc<&has_database_privilege_id>, true, true, TArgs_has_database_privilege_id_Policy>({}); }
+struct TArgs_has_database_privilege_id_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
 };
-TExecFunc arrow_int28ge() { return &GenericExec<TPgDirectFunc<&int28ge>, true, true, TArgs_int28ge_Policy>; }
-struct TArgs_int28gt_Policy {
+TExecFunc arrow_has_database_privilege_id_id() { return TGenericExec<TPgDirectFunc<&has_database_privilege_id_id>, true, true, TArgs_has_database_privilege_id_id_Policy>({}); }
+struct TArgs_has_database_privilege_id_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
 };
-TExecFunc arrow_int28gt() { return &GenericExec<TPgDirectFunc<&int28gt>, true, true, TArgs_int28gt_Policy>; }
-struct TArgs_int28le_Policy {
+TExecFunc arrow_has_database_privilege_id_name() { return TGenericExec<TPgDirectFunc<&has_database_privilege_id_name>, true, true, TArgs_has_database_privilege_id_name_Policy>({}); }
+struct TArgs_has_database_privilege_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_int28le() { return &GenericExec<TPgDirectFunc<&int28le>, true, true, TArgs_int28le_Policy>; }
-struct TArgs_int28lt_Policy {
+TExecFunc arrow_has_database_privilege_name() { return TGenericExec<TPgDirectFunc<&has_database_privilege_name>, true, true, TArgs_has_database_privilege_name_Policy>({}); }
+struct TArgs_has_database_privilege_name_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
 };
-TExecFunc arrow_int28lt() { return &GenericExec<TPgDirectFunc<&int28lt>, true, true, TArgs_int28lt_Policy>; }
-struct TArgs_int28mi_Policy {
+TExecFunc arrow_has_database_privilege_name_id() { return TGenericExec<TPgDirectFunc<&has_database_privilege_name_id>, true, true, TArgs_has_database_privilege_name_id_Policy>({}); }
+struct TArgs_has_database_privilege_name_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
 };
-TExecFunc arrow_int28mi() { return &GenericExec<TPgDirectFunc<&int28mi>, true, true, TArgs_int28mi_Policy>; }
-struct TArgs_int28mul_Policy {
+TExecFunc arrow_has_database_privilege_name_name() { return TGenericExec<TPgDirectFunc<&has_database_privilege_name_name>, true, true, TArgs_has_database_privilege_name_name_Policy>({}); }
+struct TArgs_has_foreign_data_wrapper_privilege_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_int28mul() { return &GenericExec<TPgDirectFunc<&int28mul>, true, true, TArgs_int28mul_Policy>; }
-struct TArgs_int28ne_Policy {
+TExecFunc arrow_has_foreign_data_wrapper_privilege_id() { return TGenericExec<TPgDirectFunc<&has_foreign_data_wrapper_privilege_id>, true, true, TArgs_has_foreign_data_wrapper_privilege_id_Policy>({}); }
+struct TArgs_has_foreign_data_wrapper_privilege_id_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
 };
-TExecFunc arrow_int28ne() { return &GenericExec<TPgDirectFunc<&int28ne>, true, true, TArgs_int28ne_Policy>; }
-struct TArgs_int28pl_Policy {
+TExecFunc arrow_has_foreign_data_wrapper_privilege_id_id() { return TGenericExec<TPgDirectFunc<&has_foreign_data_wrapper_privilege_id_id>, true, true, TArgs_has_foreign_data_wrapper_privilege_id_id_Policy>({}); }
+struct TArgs_has_foreign_data_wrapper_privilege_id_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
 };
-TExecFunc arrow_int28pl() { return &GenericExec<TPgDirectFunc<&int28pl>, true, true, TArgs_int28pl_Policy>; }
-struct TArgs_int48_Policy {
+TExecFunc arrow_has_foreign_data_wrapper_privilege_id_name() { return TGenericExec<TPgDirectFunc<&has_foreign_data_wrapper_privilege_id_name>, true, true, TArgs_has_foreign_data_wrapper_privilege_id_name_Policy>({}); }
+struct TArgs_has_foreign_data_wrapper_privilege_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_int48() { return &GenericExec<TPgDirectFunc<&int48>, true, true, TArgs_int48_Policy>; }
-struct TArgs_int48div_Policy {
+TExecFunc arrow_has_foreign_data_wrapper_privilege_name() { return TGenericExec<TPgDirectFunc<&has_foreign_data_wrapper_privilege_name>, true, true, TArgs_has_foreign_data_wrapper_privilege_name_Policy>({}); }
+struct TArgs_has_foreign_data_wrapper_privilege_name_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
 };
-TExecFunc arrow_int48div() { return &GenericExec<TPgDirectFunc<&int48div>, true, true, TArgs_int48div_Policy>; }
-struct TArgs_int48eq_Policy {
+TExecFunc arrow_has_foreign_data_wrapper_privilege_name_id() { return TGenericExec<TPgDirectFunc<&has_foreign_data_wrapper_privilege_name_id>, true, true, TArgs_has_foreign_data_wrapper_privilege_name_id_Policy>({}); }
+struct TArgs_has_foreign_data_wrapper_privilege_name_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
 };
-TExecFunc arrow_int48eq() { return &GenericExec<TPgDirectFunc<&int48eq>, true, true, TArgs_int48eq_Policy>; }
-struct TArgs_int48ge_Policy {
+TExecFunc arrow_has_foreign_data_wrapper_privilege_name_name() { return TGenericExec<TPgDirectFunc<&has_foreign_data_wrapper_privilege_name_name>, true, true, TArgs_has_foreign_data_wrapper_privilege_name_name_Policy>({}); }
+struct TArgs_has_function_privilege_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_int48ge() { return &GenericExec<TPgDirectFunc<&int48ge>, true, true, TArgs_int48ge_Policy>; }
-struct TArgs_int48gt_Policy {
+TExecFunc arrow_has_function_privilege_id() { return TGenericExec<TPgDirectFunc<&has_function_privilege_id>, true, true, TArgs_has_function_privilege_id_Policy>({}); }
+struct TArgs_has_function_privilege_id_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
 };
-TExecFunc arrow_int48gt() { return &GenericExec<TPgDirectFunc<&int48gt>, true, true, TArgs_int48gt_Policy>; }
-struct TArgs_int48le_Policy {
+TExecFunc arrow_has_function_privilege_id_id() { return TGenericExec<TPgDirectFunc<&has_function_privilege_id_id>, true, true, TArgs_has_function_privilege_id_id_Policy>({}); }
+struct TArgs_has_function_privilege_id_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
 };
-TExecFunc arrow_int48le() { return &GenericExec<TPgDirectFunc<&int48le>, true, true, TArgs_int48le_Policy>; }
-struct TArgs_int48lt_Policy {
+TExecFunc arrow_has_function_privilege_id_name() { return TGenericExec<TPgDirectFunc<&has_function_privilege_id_name>, true, true, TArgs_has_function_privilege_id_name_Policy>({}); }
+struct TArgs_has_function_privilege_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_int48lt() { return &GenericExec<TPgDirectFunc<&int48lt>, true, true, TArgs_int48lt_Policy>; }
-struct TArgs_int48mi_Policy {
+TExecFunc arrow_has_function_privilege_name() { return TGenericExec<TPgDirectFunc<&has_function_privilege_name>, true, true, TArgs_has_function_privilege_name_Policy>({}); }
+struct TArgs_has_function_privilege_name_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
 };
-TExecFunc arrow_int48mi() { return &GenericExec<TPgDirectFunc<&int48mi>, true, true, TArgs_int48mi_Policy>; }
-struct TArgs_int48mul_Policy {
+TExecFunc arrow_has_function_privilege_name_id() { return TGenericExec<TPgDirectFunc<&has_function_privilege_name_id>, true, true, TArgs_has_function_privilege_name_id_Policy>({}); }
+struct TArgs_has_function_privilege_name_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
 };
-TExecFunc arrow_int48mul() { return &GenericExec<TPgDirectFunc<&int48mul>, true, true, TArgs_int48mul_Policy>; }
-struct TArgs_int48ne_Policy {
+TExecFunc arrow_has_function_privilege_name_name() { return TGenericExec<TPgDirectFunc<&has_function_privilege_name_name>, true, true, TArgs_has_function_privilege_name_name_Policy>({}); }
+struct TArgs_has_language_privilege_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_int48ne() { return &GenericExec<TPgDirectFunc<&int48ne>, true, true, TArgs_int48ne_Policy>; }
-struct TArgs_int48pl_Policy {
+TExecFunc arrow_has_language_privilege_id() { return TGenericExec<TPgDirectFunc<&has_language_privilege_id>, true, true, TArgs_has_language_privilege_id_Policy>({}); }
+struct TArgs_has_language_privilege_id_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
 };
-TExecFunc arrow_int48pl() { return &GenericExec<TPgDirectFunc<&int48pl>, true, true, TArgs_int48pl_Policy>; }
-struct TArgs_int4range_canonical_Policy {
+TExecFunc arrow_has_language_privilege_id_id() { return TGenericExec<TPgDirectFunc<&has_language_privilege_id_id>, true, true, TArgs_has_language_privilege_id_id_Policy>({}); }
+struct TArgs_has_language_privilege_id_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
 };
-TExecFunc arrow_int4range_canonical() { return &GenericExec<TPgDirectFunc<&int4range_canonical>, true, false, TArgs_int4range_canonical_Policy>; }
-struct TArgs_int4range_subdiff_Policy {
+TExecFunc arrow_has_language_privilege_id_name() { return TGenericExec<TPgDirectFunc<&has_language_privilege_id_name>, true, true, TArgs_has_language_privilege_id_name_Policy>({}); }
+struct TArgs_has_language_privilege_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_int4range_subdiff() { return &GenericExec<TPgDirectFunc<&int4range_subdiff>, true, true, TArgs_int4range_subdiff_Policy>; }
-struct TArgs_int82_Policy {
+TExecFunc arrow_has_language_privilege_name() { return TGenericExec<TPgDirectFunc<&has_language_privilege_name>, true, true, TArgs_has_language_privilege_name_Policy>({}); }
+struct TArgs_has_language_privilege_name_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
 };
-TExecFunc arrow_int82() { return &GenericExec<TPgDirectFunc<&int82>, true, true, TArgs_int82_Policy>; }
-struct TArgs_int82div_Policy {
+TExecFunc arrow_has_language_privilege_name_id() { return TGenericExec<TPgDirectFunc<&has_language_privilege_name_id>, true, true, TArgs_has_language_privilege_name_id_Policy>({}); }
+struct TArgs_has_language_privilege_name_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
 };
-TExecFunc arrow_int82div() { return &GenericExec<TPgDirectFunc<&int82div>, true, true, TArgs_int82div_Policy>; }
-struct TArgs_int82eq_Policy {
+TExecFunc arrow_has_language_privilege_name_name() { return TGenericExec<TPgDirectFunc<&has_language_privilege_name_name>, true, true, TArgs_has_language_privilege_name_name_Policy>({}); }
+struct TArgs_has_schema_privilege_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_int82eq() { return &GenericExec<TPgDirectFunc<&int82eq>, true, true, TArgs_int82eq_Policy>; }
-struct TArgs_int82ge_Policy {
+TExecFunc arrow_has_schema_privilege_id() { return TGenericExec<TPgDirectFunc<&has_schema_privilege_id>, true, true, TArgs_has_schema_privilege_id_Policy>({}); }
+struct TArgs_has_schema_privilege_id_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
 };
-TExecFunc arrow_int82ge() { return &GenericExec<TPgDirectFunc<&int82ge>, true, true, TArgs_int82ge_Policy>; }
-struct TArgs_int82gt_Policy {
+TExecFunc arrow_has_schema_privilege_id_id() { return TGenericExec<TPgDirectFunc<&has_schema_privilege_id_id>, true, true, TArgs_has_schema_privilege_id_id_Policy>({}); }
+struct TArgs_has_schema_privilege_id_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
 };
-TExecFunc arrow_int82gt() { return &GenericExec<TPgDirectFunc<&int82gt>, true, true, TArgs_int82gt_Policy>; }
-struct TArgs_int82le_Policy {
+TExecFunc arrow_has_schema_privilege_id_name() { return TGenericExec<TPgDirectFunc<&has_schema_privilege_id_name>, true, true, TArgs_has_schema_privilege_id_name_Policy>({}); }
+struct TArgs_has_schema_privilege_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_int82le() { return &GenericExec<TPgDirectFunc<&int82le>, true, true, TArgs_int82le_Policy>; }
-struct TArgs_int82lt_Policy {
+TExecFunc arrow_has_schema_privilege_name() { return TGenericExec<TPgDirectFunc<&has_schema_privilege_name>, true, true, TArgs_has_schema_privilege_name_Policy>({}); }
+struct TArgs_has_schema_privilege_name_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
 };
-TExecFunc arrow_int82lt() { return &GenericExec<TPgDirectFunc<&int82lt>, true, true, TArgs_int82lt_Policy>; }
-struct TArgs_int82mi_Policy {
+TExecFunc arrow_has_schema_privilege_name_id() { return TGenericExec<TPgDirectFunc<&has_schema_privilege_name_id>, true, true, TArgs_has_schema_privilege_name_id_Policy>({}); }
+struct TArgs_has_schema_privilege_name_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
 };
-TExecFunc arrow_int82mi() { return &GenericExec<TPgDirectFunc<&int82mi>, true, true, TArgs_int82mi_Policy>; }
-struct TArgs_int82mul_Policy {
+TExecFunc arrow_has_schema_privilege_name_name() { return TGenericExec<TPgDirectFunc<&has_schema_privilege_name_name>, true, true, TArgs_has_schema_privilege_name_name_Policy>({}); }
+struct TArgs_has_sequence_privilege_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_int82mul() { return &GenericExec<TPgDirectFunc<&int82mul>, true, true, TArgs_int82mul_Policy>; }
-struct TArgs_int82ne_Policy {
+TExecFunc arrow_has_sequence_privilege_id() { return TGenericExec<TPgDirectFunc<&has_sequence_privilege_id>, true, true, TArgs_has_sequence_privilege_id_Policy>({}); }
+struct TArgs_has_sequence_privilege_id_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
 };
-TExecFunc arrow_int82ne() { return &GenericExec<TPgDirectFunc<&int82ne>, true, true, TArgs_int82ne_Policy>; }
-struct TArgs_int82pl_Policy {
+TExecFunc arrow_has_sequence_privilege_id_id() { return TGenericExec<TPgDirectFunc<&has_sequence_privilege_id_id>, true, true, TArgs_has_sequence_privilege_id_id_Policy>({}); }
+struct TArgs_has_sequence_privilege_id_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
 };
-TExecFunc arrow_int82pl() { return &GenericExec<TPgDirectFunc<&int82pl>, true, true, TArgs_int82pl_Policy>; }
-struct TArgs_int84_Policy {
+TExecFunc arrow_has_sequence_privilege_id_name() { return TGenericExec<TPgDirectFunc<&has_sequence_privilege_id_name>, true, true, TArgs_has_sequence_privilege_id_name_Policy>({}); }
+struct TArgs_has_sequence_privilege_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_int84() { return &GenericExec<TPgDirectFunc<&int84>, true, true, TArgs_int84_Policy>; }
-struct TArgs_int84div_Policy {
+TExecFunc arrow_has_sequence_privilege_name() { return TGenericExec<TPgDirectFunc<&has_sequence_privilege_name>, true, true, TArgs_has_sequence_privilege_name_Policy>({}); }
+struct TArgs_has_sequence_privilege_name_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
 };
-TExecFunc arrow_int84div() { return &GenericExec<TPgDirectFunc<&int84div>, true, true, TArgs_int84div_Policy>; }
-struct TArgs_int84eq_Policy {
+TExecFunc arrow_has_sequence_privilege_name_id() { return TGenericExec<TPgDirectFunc<&has_sequence_privilege_name_id>, true, true, TArgs_has_sequence_privilege_name_id_Policy>({}); }
+struct TArgs_has_sequence_privilege_name_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
 };
-TExecFunc arrow_int84eq() { return &GenericExec<TPgDirectFunc<&int84eq>, true, true, TArgs_int84eq_Policy>; }
-struct TArgs_int84ge_Policy {
+TExecFunc arrow_has_sequence_privilege_name_name() { return TGenericExec<TPgDirectFunc<&has_sequence_privilege_name_name>, true, true, TArgs_has_sequence_privilege_name_name_Policy>({}); }
+struct TArgs_has_server_privilege_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_int84ge() { return &GenericExec<TPgDirectFunc<&int84ge>, true, true, TArgs_int84ge_Policy>; }
-struct TArgs_int84gt_Policy {
+TExecFunc arrow_has_server_privilege_id() { return TGenericExec<TPgDirectFunc<&has_server_privilege_id>, true, true, TArgs_has_server_privilege_id_Policy>({}); }
+struct TArgs_has_server_privilege_id_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
 };
-TExecFunc arrow_int84gt() { return &GenericExec<TPgDirectFunc<&int84gt>, true, true, TArgs_int84gt_Policy>; }
-struct TArgs_int84le_Policy {
+TExecFunc arrow_has_server_privilege_id_id() { return TGenericExec<TPgDirectFunc<&has_server_privilege_id_id>, true, true, TArgs_has_server_privilege_id_id_Policy>({}); }
+struct TArgs_has_server_privilege_id_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
 };
-TExecFunc arrow_int84le() { return &GenericExec<TPgDirectFunc<&int84le>, true, true, TArgs_int84le_Policy>; }
-struct TArgs_int84lt_Policy {
+TExecFunc arrow_has_server_privilege_id_name() { return TGenericExec<TPgDirectFunc<&has_server_privilege_id_name>, true, true, TArgs_has_server_privilege_id_name_Policy>({}); }
+struct TArgs_has_server_privilege_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_int84lt() { return &GenericExec<TPgDirectFunc<&int84lt>, true, true, TArgs_int84lt_Policy>; }
-struct TArgs_int84mi_Policy {
+TExecFunc arrow_has_server_privilege_name() { return TGenericExec<TPgDirectFunc<&has_server_privilege_name>, true, true, TArgs_has_server_privilege_name_Policy>({}); }
+struct TArgs_has_server_privilege_name_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
 };
-TExecFunc arrow_int84mi() { return &GenericExec<TPgDirectFunc<&int84mi>, true, true, TArgs_int84mi_Policy>; }
-struct TArgs_int84mul_Policy {
+TExecFunc arrow_has_server_privilege_name_id() { return TGenericExec<TPgDirectFunc<&has_server_privilege_name_id>, true, true, TArgs_has_server_privilege_name_id_Policy>({}); }
+struct TArgs_has_server_privilege_name_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
 };
-TExecFunc arrow_int84mul() { return &GenericExec<TPgDirectFunc<&int84mul>, true, true, TArgs_int84mul_Policy>; }
-struct TArgs_int84ne_Policy {
+TExecFunc arrow_has_server_privilege_name_name() { return TGenericExec<TPgDirectFunc<&has_server_privilege_name_name>, true, true, TArgs_has_server_privilege_name_name_Policy>({}); }
+struct TArgs_has_table_privilege_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_int84ne() { return &GenericExec<TPgDirectFunc<&int84ne>, true, true, TArgs_int84ne_Policy>; }
-struct TArgs_int84pl_Policy {
+TExecFunc arrow_has_table_privilege_id() { return TGenericExec<TPgDirectFunc<&has_table_privilege_id>, true, true, TArgs_has_table_privilege_id_Policy>({}); }
+struct TArgs_has_table_privilege_id_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
 };
-TExecFunc arrow_int84pl() { return &GenericExec<TPgDirectFunc<&int84pl>, true, true, TArgs_int84pl_Policy>; }
-struct TArgs_int8abs_Policy {
+TExecFunc arrow_has_table_privilege_id_id() { return TGenericExec<TPgDirectFunc<&has_table_privilege_id_id>, true, true, TArgs_has_table_privilege_id_id_Policy>({}); }
+struct TArgs_has_table_privilege_id_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
 };
-TExecFunc arrow_int8abs() { return &GenericExec<TPgDirectFunc<&int8abs>, true, true, TArgs_int8abs_Policy>; }
-struct TArgs_int8and_Policy {
+TExecFunc arrow_has_table_privilege_id_name() { return TGenericExec<TPgDirectFunc<&has_table_privilege_id_name>, true, true, TArgs_has_table_privilege_id_name_Policy>({}); }
+struct TArgs_has_table_privilege_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_int8and() { return &GenericExec<TPgDirectFunc<&int8and>, true, true, TArgs_int8and_Policy>; }
-struct TArgs_int8dec_Policy {
+TExecFunc arrow_has_table_privilege_name() { return TGenericExec<TPgDirectFunc<&has_table_privilege_name>, true, true, TArgs_has_table_privilege_name_Policy>({}); }
+struct TArgs_has_table_privilege_name_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
 };
-TExecFunc arrow_int8dec() { return &GenericExec<TPgDirectFunc<&int8dec>, true, true, TArgs_int8dec_Policy>; }
-struct TArgs_int8dec_any_Policy {
+TExecFunc arrow_has_table_privilege_name_id() { return TGenericExec<TPgDirectFunc<&has_table_privilege_name_id>, true, true, TArgs_has_table_privilege_name_id_Policy>({}); }
+struct TArgs_has_table_privilege_name_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
 };
-TExecFunc arrow_int8dec_any() { return &GenericExec<TPgDirectFunc<&int8dec_any>, true, true, TArgs_int8dec_any_Policy>; }
-struct TArgs_int8div_Policy {
+TExecFunc arrow_has_table_privilege_name_name() { return TGenericExec<TPgDirectFunc<&has_table_privilege_name_name>, true, true, TArgs_has_table_privilege_name_name_Policy>({}); }
+struct TArgs_has_tablespace_privilege_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_int8div() { return &GenericExec<TPgDirectFunc<&int8div>, true, true, TArgs_int8div_Policy>; }
-struct TArgs_int8eq_Policy {
+TExecFunc arrow_has_tablespace_privilege_id() { return TGenericExec<TPgDirectFunc<&has_tablespace_privilege_id>, true, true, TArgs_has_tablespace_privilege_id_Policy>({}); }
+struct TArgs_has_tablespace_privilege_id_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
 };
-TExecFunc arrow_int8eq() { return &GenericExec<TPgDirectFunc<&int8eq>, true, true, TArgs_int8eq_Policy>; }
-struct TArgs_int8gcd_Policy {
+TExecFunc arrow_has_tablespace_privilege_id_id() { return TGenericExec<TPgDirectFunc<&has_tablespace_privilege_id_id>, true, true, TArgs_has_tablespace_privilege_id_id_Policy>({}); }
+struct TArgs_has_tablespace_privilege_id_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
 };
-TExecFunc arrow_int8gcd() { return &GenericExec<TPgDirectFunc<&int8gcd>, true, true, TArgs_int8gcd_Policy>; }
-struct TArgs_int8ge_Policy {
+TExecFunc arrow_has_tablespace_privilege_id_name() { return TGenericExec<TPgDirectFunc<&has_tablespace_privilege_id_name>, true, true, TArgs_has_tablespace_privilege_id_name_Policy>({}); }
+struct TArgs_has_tablespace_privilege_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_int8ge() { return &GenericExec<TPgDirectFunc<&int8ge>, true, true, TArgs_int8ge_Policy>; }
-struct TArgs_int8gt_Policy {
+TExecFunc arrow_has_tablespace_privilege_name() { return TGenericExec<TPgDirectFunc<&has_tablespace_privilege_name>, true, true, TArgs_has_tablespace_privilege_name_Policy>({}); }
+struct TArgs_has_tablespace_privilege_name_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
 };
-TExecFunc arrow_int8gt() { return &GenericExec<TPgDirectFunc<&int8gt>, true, true, TArgs_int8gt_Policy>; }
-struct TArgs_int8in_Policy {
+TExecFunc arrow_has_tablespace_privilege_name_id() { return TGenericExec<TPgDirectFunc<&has_tablespace_privilege_name_id>, true, true, TArgs_has_tablespace_privilege_name_id_Policy>({}); }
+struct TArgs_has_tablespace_privilege_name_name_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+};
+TExecFunc arrow_has_tablespace_privilege_name_name() { return TGenericExec<TPgDirectFunc<&has_tablespace_privilege_name_name>, true, true, TArgs_has_tablespace_privilege_name_name_Policy>({}); }
+struct TArgs_has_type_privilege_id_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+};
+TExecFunc arrow_has_type_privilege_id() { return TGenericExec<TPgDirectFunc<&has_type_privilege_id>, true, true, TArgs_has_type_privilege_id_Policy>({}); }
+struct TArgs_has_type_privilege_id_id_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
+};
+TExecFunc arrow_has_type_privilege_id_id() { return TGenericExec<TPgDirectFunc<&has_type_privilege_id_id>, true, true, TArgs_has_type_privilege_id_id_Policy>({}); }
+struct TArgs_has_type_privilege_id_name_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
+};
+TExecFunc arrow_has_type_privilege_id_name() { return TGenericExec<TPgDirectFunc<&has_type_privilege_id_name>, true, true, TArgs_has_type_privilege_id_name_Policy>({}); }
+struct TArgs_has_type_privilege_name_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_has_type_privilege_name() { return TGenericExec<TPgDirectFunc<&has_type_privilege_name>, true, true, TArgs_has_type_privilege_name_Policy>({}); }
+struct TArgs_has_type_privilege_name_id_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
+};
+TExecFunc arrow_has_type_privilege_name_id() { return TGenericExec<TPgDirectFunc<&has_type_privilege_name_id>, true, true, TArgs_has_type_privilege_name_id_Policy>({}); }
+struct TArgs_has_type_privilege_name_name_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+};
+TExecFunc arrow_has_type_privilege_name_name() { return TGenericExec<TPgDirectFunc<&has_type_privilege_name_name>, true, true, TArgs_has_type_privilege_name_name_Policy>({}); }
+struct TArgs_hash_aclitem_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_int8in() { return &GenericExec<TPgDirectFunc<&int8in>, true, true, TArgs_int8in_Policy>; }
-struct TArgs_int8inc_Policy {
+TExecFunc arrow_hash_aclitem() { return TGenericExec<TPgDirectFunc<&hash_aclitem>, true, true, TArgs_hash_aclitem_Policy>({}); }
+struct TArgs_hash_aclitem_extended_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+};
+TExecFunc arrow_hash_aclitem_extended() { return TGenericExec<TPgDirectFunc<&hash_aclitem_extended>, true, true, TArgs_hash_aclitem_extended_Policy>({}); }
+struct TArgs_hash_array_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_hash_array() { return TGenericExec<TPgDirectFunc<&hash_array>, true, true, TArgs_hash_array_Policy>({}); }
+struct TArgs_hash_array_extended_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+};
+TExecFunc arrow_hash_array_extended() { return TGenericExec<TPgDirectFunc<&hash_array_extended>, true, true, TArgs_hash_array_extended_Policy>({}); }
+struct TArgs_i2toi4_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int8inc() { return &GenericExec<TPgDirectFunc<&int8inc>, true, true, TArgs_int8inc_Policy>; }
-struct TArgs_int8inc_any_Policy {
+TExecFunc arrow_i2toi4() { return TGenericExec<TPgDirectFunc<&i2toi4>, true, true, TArgs_i2toi4_Policy>({}); }
+struct TArgs_i4toi2_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int8inc_any() { return &GenericExec<TPgDirectFunc<&int8inc_any>, true, true, TArgs_int8inc_any_Policy>; }
-struct TArgs_int8inc_float8_float8_Policy {
+TExecFunc arrow_i4toi2() { return TGenericExec<TPgDirectFunc<&i4toi2>, true, true, TArgs_i4toi2_Policy>({}); }
+struct TArgs_i8tod_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int8inc_float8_float8() { return &GenericExec<TPgDirectFunc<&int8inc_float8_float8>, true, true, TArgs_int8inc_float8_float8_Policy>; }
-struct TArgs_int8larger_Policy {
+TExecFunc arrow_i8tod() { return TGenericExec<TPgDirectFunc<&i8tod>, true, true, TArgs_i8tod_Policy>({}); }
+struct TArgs_i8tof_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int8larger() { return &GenericExec<TPgDirectFunc<&int8larger>, true, true, TArgs_int8larger_Policy>; }
-struct TArgs_int8lcm_Policy {
+TExecFunc arrow_i8tof() { return TGenericExec<TPgDirectFunc<&i8tof>, true, true, TArgs_i8tof_Policy>({}); }
+struct TArgs_i8tooid_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int8lcm() { return &GenericExec<TPgDirectFunc<&int8lcm>, true, true, TArgs_int8lcm_Policy>; }
-struct TArgs_int8le_Policy {
+TExecFunc arrow_i8tooid() { return TGenericExec<TPgDirectFunc<&i8tooid>, true, true, TArgs_i8tooid_Policy>({}); }
+struct TArgs_in_range_date_interval_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,false,true,true};
 };
-TExecFunc arrow_int8le() { return &GenericExec<TPgDirectFunc<&int8le>, true, true, TArgs_int8le_Policy>; }
-struct TArgs_int8lt_Policy {
+TExecFunc arrow_in_range_date_interval() { return TGenericExec<TPgDirectFunc<&in_range_date_interval>, true, true, TArgs_in_range_date_interval_Policy>({}); }
+struct TArgs_in_range_int2_int2_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
 };
-TExecFunc arrow_int8lt() { return &GenericExec<TPgDirectFunc<&int8lt>, true, true, TArgs_int8lt_Policy>; }
-struct TArgs_int8mi_Policy {
+TExecFunc arrow_in_range_int2_int2() { return TGenericExec<TPgDirectFunc<&in_range_int2_int2>, true, true, TArgs_in_range_int2_int2_Policy>({}); }
+struct TArgs_in_range_int2_int4_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
 };
-TExecFunc arrow_int8mi() { return &GenericExec<TPgDirectFunc<&int8mi>, true, true, TArgs_int8mi_Policy>; }
-struct TArgs_int8mod_Policy {
+TExecFunc arrow_in_range_int2_int4() { return TGenericExec<TPgDirectFunc<&in_range_int2_int4>, true, true, TArgs_in_range_int2_int4_Policy>({}); }
+struct TArgs_in_range_int2_int8_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+};
+TExecFunc arrow_in_range_int2_int8() { return TGenericExec<TPgDirectFunc<&in_range_int2_int8>, true, true, TArgs_in_range_int2_int8_Policy>({}); }
+struct TArgs_in_range_int4_int2_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+};
+TExecFunc arrow_in_range_int4_int2() { return TGenericExec<TPgDirectFunc<&in_range_int4_int2>, true, true, TArgs_in_range_int4_int2_Policy>({}); }
+struct TArgs_in_range_int4_int4_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+};
+TExecFunc arrow_in_range_int4_int4() { return TGenericExec<TPgDirectFunc<&in_range_int4_int4>, true, true, TArgs_in_range_int4_int4_Policy>({}); }
+struct TArgs_in_range_int4_int8_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+};
+TExecFunc arrow_in_range_int4_int8() { return TGenericExec<TPgDirectFunc<&in_range_int4_int8>, true, true, TArgs_in_range_int4_int8_Policy>({}); }
+struct TArgs_in_range_int8_int8_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+};
+TExecFunc arrow_in_range_int8_int8() { return TGenericExec<TPgDirectFunc<&in_range_int8_int8>, true, true, TArgs_in_range_int8_int8_Policy>({}); }
+struct TArgs_in_range_time_interval_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,false,true,true};
+};
+TExecFunc arrow_in_range_time_interval() { return TGenericExec<TPgDirectFunc<&in_range_time_interval>, true, true, TArgs_in_range_time_interval_Policy>({}); }
+struct TArgs_in_range_timetz_interval_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 5> IsFixedArg = {false,false,false,true,true};
+};
+TExecFunc arrow_in_range_timetz_interval() { return TGenericExec<TPgDirectFunc<&in_range_timetz_interval>, true, true, TArgs_in_range_timetz_interval_Policy>({}); }
+struct TArgs_inet_spg_choose_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int8mod() { return &GenericExec<TPgDirectFunc<&int8mod>, true, true, TArgs_int8mod_Policy>; }
-struct TArgs_int8mul_Policy {
+TExecFunc arrow_inet_spg_choose() { return TGenericExec<TPgDirectFunc<&inet_spg_choose>, true, true, TArgs_inet_spg_choose_Policy>({}); }
+struct TArgs_inet_spg_config_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int8mul() { return &GenericExec<TPgDirectFunc<&int8mul>, true, true, TArgs_int8mul_Policy>; }
-struct TArgs_int8ne_Policy {
+TExecFunc arrow_inet_spg_config() { return TGenericExec<TPgDirectFunc<&inet_spg_config>, true, true, TArgs_inet_spg_config_Policy>({}); }
+struct TArgs_inet_spg_inner_consistent_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int8ne() { return &GenericExec<TPgDirectFunc<&int8ne>, true, true, TArgs_int8ne_Policy>; }
-struct TArgs_int8not_Policy {
+TExecFunc arrow_inet_spg_inner_consistent() { return TGenericExec<TPgDirectFunc<&inet_spg_inner_consistent>, true, true, TArgs_inet_spg_inner_consistent_Policy>({}); }
+struct TArgs_inet_spg_leaf_consistent_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int8not() { return &GenericExec<TPgDirectFunc<&int8not>, true, true, TArgs_int8not_Policy>; }
-struct TArgs_int8or_Policy {
+TExecFunc arrow_inet_spg_leaf_consistent() { return TGenericExec<TPgDirectFunc<&inet_spg_leaf_consistent>, true, true, TArgs_inet_spg_leaf_consistent_Policy>({}); }
+struct TArgs_inet_spg_picksplit_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int8or() { return &GenericExec<TPgDirectFunc<&int8or>, true, true, TArgs_int8or_Policy>; }
-struct TArgs_int8out_Policy {
+TExecFunc arrow_inet_spg_picksplit() { return TGenericExec<TPgDirectFunc<&inet_spg_picksplit>, true, true, TArgs_inet_spg_picksplit_Policy>({}); }
+struct TArgs_int24div_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int8out() { return &GenericExec<TPgDirectFunc<&int8out>, true, false, TArgs_int8out_Policy>; }
-struct TArgs_int8pl_Policy {
+TExecFunc arrow_int24div() { return TGenericExec<TPgDirectFunc<&int24div>, true, true, TArgs_int24div_Policy>({}); }
+struct TArgs_int24eq_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int8pl() { return &GenericExec<TPgDirectFunc<&int8pl>, true, true, TArgs_int8pl_Policy>; }
-struct TArgs_int8range_canonical_Policy {
+TExecFunc arrow_int24eq() { return TGenericExec<TPgDirectFunc<&int24eq>, true, true, TArgs_int24eq_Policy>({}); }
+struct TArgs_int24ge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int8range_canonical() { return &GenericExec<TPgDirectFunc<&int8range_canonical>, true, false, TArgs_int8range_canonical_Policy>; }
-struct TArgs_int8range_subdiff_Policy {
+TExecFunc arrow_int24ge() { return TGenericExec<TPgDirectFunc<&int24ge>, true, true, TArgs_int24ge_Policy>({}); }
+struct TArgs_int24gt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int8range_subdiff() { return &GenericExec<TPgDirectFunc<&int8range_subdiff>, true, true, TArgs_int8range_subdiff_Policy>; }
-struct TArgs_int8recv_Policy {
+TExecFunc arrow_int24gt() { return TGenericExec<TPgDirectFunc<&int24gt>, true, true, TArgs_int24gt_Policy>({}); }
+struct TArgs_int24le_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int8recv() { return &GenericExec<TPgDirectFunc<&int8recv>, true, true, TArgs_int8recv_Policy>; }
-struct TArgs_int8send_Policy {
+TExecFunc arrow_int24le() { return TGenericExec<TPgDirectFunc<&int24le>, true, true, TArgs_int24le_Policy>({}); }
+struct TArgs_int24lt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int8send() { return &GenericExec<TPgDirectFunc<&int8send>, true, false, TArgs_int8send_Policy>; }
-struct TArgs_int8shl_Policy {
+TExecFunc arrow_int24lt() { return TGenericExec<TPgDirectFunc<&int24lt>, true, true, TArgs_int24lt_Policy>({}); }
+struct TArgs_int24mi_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int8shl() { return &GenericExec<TPgDirectFunc<&int8shl>, true, true, TArgs_int8shl_Policy>; }
-struct TArgs_int8shr_Policy {
+TExecFunc arrow_int24mi() { return TGenericExec<TPgDirectFunc<&int24mi>, true, true, TArgs_int24mi_Policy>({}); }
+struct TArgs_int24mul_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int8shr() { return &GenericExec<TPgDirectFunc<&int8shr>, true, true, TArgs_int8shr_Policy>; }
-struct TArgs_int8smaller_Policy {
+TExecFunc arrow_int24mul() { return TGenericExec<TPgDirectFunc<&int24mul>, true, true, TArgs_int24mul_Policy>({}); }
+struct TArgs_int24ne_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int8smaller() { return &GenericExec<TPgDirectFunc<&int8smaller>, true, true, TArgs_int8smaller_Policy>; }
-struct TArgs_int8um_Policy {
+TExecFunc arrow_int24ne() { return TGenericExec<TPgDirectFunc<&int24ne>, true, true, TArgs_int24ne_Policy>({}); }
+struct TArgs_int24pl_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int8um() { return &GenericExec<TPgDirectFunc<&int8um>, true, true, TArgs_int8um_Policy>; }
-struct TArgs_int8up_Policy {
+TExecFunc arrow_int24pl() { return TGenericExec<TPgDirectFunc<&int24pl>, true, true, TArgs_int24pl_Policy>({}); }
+struct TArgs_int28_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int8up() { return &GenericExec<TPgDirectFunc<&int8up>, true, true, TArgs_int8up_Policy>; }
-struct TArgs_int8xor_Policy {
+TExecFunc arrow_int28() { return TGenericExec<TPgDirectFunc<&int28>, true, true, TArgs_int28_Policy>({}); }
+struct TArgs_int28div_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_int8xor() { return &GenericExec<TPgDirectFunc<&int8xor>, true, true, TArgs_int8xor_Policy>; }
-struct TArgs_interval_time_Policy {
+TExecFunc arrow_int28div() { return TGenericExec<TPgDirectFunc<&int28div>, true, true, TArgs_int28div_Policy>({}); }
+struct TArgs_int28eq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_interval_time() { return &GenericExec<TPgDirectFunc<&interval_time>, true, true, TArgs_interval_time_Policy>; }
-struct TArgs_lastval_Policy {
+TExecFunc arrow_int28eq() { return TGenericExec<TPgDirectFunc<&int28eq>, true, true, TArgs_int28eq_Policy>({}); }
+struct TArgs_int28ge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_lastval() { return &GenericExec<TPgDirectFunc<&lastval>, true, true, TArgs_lastval_Policy>; }
-struct TArgs_macaddr8_and_Policy {
+TExecFunc arrow_int28ge() { return TGenericExec<TPgDirectFunc<&int28ge>, true, true, TArgs_int28ge_Policy>({}); }
+struct TArgs_int28gt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_macaddr8_and() { return &GenericExec<TPgDirectFunc<&macaddr8_and>, true, false, TArgs_macaddr8_and_Policy>; }
-struct TArgs_macaddr8_cmp_Policy {
+TExecFunc arrow_int28gt() { return TGenericExec<TPgDirectFunc<&int28gt>, true, true, TArgs_int28gt_Policy>({}); }
+struct TArgs_int28le_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_macaddr8_cmp() { return &GenericExec<TPgDirectFunc<&macaddr8_cmp>, true, true, TArgs_macaddr8_cmp_Policy>; }
-struct TArgs_macaddr8_eq_Policy {
+TExecFunc arrow_int28le() { return TGenericExec<TPgDirectFunc<&int28le>, true, true, TArgs_int28le_Policy>({}); }
+struct TArgs_int28lt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_macaddr8_eq() { return &GenericExec<TPgDirectFunc<&macaddr8_eq>, true, true, TArgs_macaddr8_eq_Policy>; }
-struct TArgs_macaddr8_ge_Policy {
+TExecFunc arrow_int28lt() { return TGenericExec<TPgDirectFunc<&int28lt>, true, true, TArgs_int28lt_Policy>({}); }
+struct TArgs_int28mi_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_macaddr8_ge() { return &GenericExec<TPgDirectFunc<&macaddr8_ge>, true, true, TArgs_macaddr8_ge_Policy>; }
-struct TArgs_macaddr8_gt_Policy {
+TExecFunc arrow_int28mi() { return TGenericExec<TPgDirectFunc<&int28mi>, true, true, TArgs_int28mi_Policy>({}); }
+struct TArgs_int28mul_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_macaddr8_gt() { return &GenericExec<TPgDirectFunc<&macaddr8_gt>, true, true, TArgs_macaddr8_gt_Policy>; }
-struct TArgs_macaddr8_in_Policy {
+TExecFunc arrow_int28mul() { return TGenericExec<TPgDirectFunc<&int28mul>, true, true, TArgs_int28mul_Policy>({}); }
+struct TArgs_int28ne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_macaddr8_in() { return &GenericExec<TPgDirectFunc<&macaddr8_in>, true, false, TArgs_macaddr8_in_Policy>; }
-struct TArgs_macaddr8_le_Policy {
+TExecFunc arrow_int28ne() { return TGenericExec<TPgDirectFunc<&int28ne>, true, true, TArgs_int28ne_Policy>({}); }
+struct TArgs_int28pl_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_macaddr8_le() { return &GenericExec<TPgDirectFunc<&macaddr8_le>, true, true, TArgs_macaddr8_le_Policy>; }
-struct TArgs_macaddr8_lt_Policy {
+TExecFunc arrow_int28pl() { return TGenericExec<TPgDirectFunc<&int28pl>, true, true, TArgs_int28pl_Policy>({}); }
+struct TArgs_int2abs_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_macaddr8_lt() { return &GenericExec<TPgDirectFunc<&macaddr8_lt>, true, true, TArgs_macaddr8_lt_Policy>; }
-struct TArgs_macaddr8_ne_Policy {
+TExecFunc arrow_int2abs() { return TGenericExec<TPgDirectFunc<&int2abs>, true, true, TArgs_int2abs_Policy>({}); }
+struct TArgs_int2and_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_macaddr8_ne() { return &GenericExec<TPgDirectFunc<&macaddr8_ne>, true, true, TArgs_macaddr8_ne_Policy>; }
-struct TArgs_macaddr8_not_Policy {
+TExecFunc arrow_int2and() { return TGenericExec<TPgDirectFunc<&int2and>, true, true, TArgs_int2and_Policy>({}); }
+struct TArgs_int2div_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_macaddr8_not() { return &GenericExec<TPgDirectFunc<&macaddr8_not>, true, false, TArgs_macaddr8_not_Policy>; }
-struct TArgs_macaddr8_or_Policy {
+TExecFunc arrow_int2div() { return TGenericExec<TPgDirectFunc<&int2div>, true, true, TArgs_int2div_Policy>({}); }
+struct TArgs_int2eq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_macaddr8_or() { return &GenericExec<TPgDirectFunc<&macaddr8_or>, true, false, TArgs_macaddr8_or_Policy>; }
-struct TArgs_macaddr8_out_Policy {
+TExecFunc arrow_int2eq() { return TGenericExec<TPgDirectFunc<&int2eq>, true, true, TArgs_int2eq_Policy>({}); }
+struct TArgs_int2ge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_macaddr8_out() { return &GenericExec<TPgDirectFunc<&macaddr8_out>, true, false, TArgs_macaddr8_out_Policy>; }
-struct TArgs_macaddr8_recv_Policy {
+TExecFunc arrow_int2ge() { return TGenericExec<TPgDirectFunc<&int2ge>, true, true, TArgs_int2ge_Policy>({}); }
+struct TArgs_int2gt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_macaddr8_recv() { return &GenericExec<TPgDirectFunc<&macaddr8_recv>, true, false, TArgs_macaddr8_recv_Policy>; }
-struct TArgs_macaddr8_send_Policy {
+TExecFunc arrow_int2gt() { return TGenericExec<TPgDirectFunc<&int2gt>, true, true, TArgs_int2gt_Policy>({}); }
+struct TArgs_int2in_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_macaddr8_send() { return &GenericExec<TPgDirectFunc<&macaddr8_send>, true, false, TArgs_macaddr8_send_Policy>; }
-struct TArgs_macaddr8_set7bit_Policy {
+TExecFunc arrow_int2in() { return TGenericExec<TPgDirectFunc<&int2in>, true, true, TArgs_int2in_Policy>({}); }
+struct TArgs_int2larger_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_macaddr8_set7bit() { return &GenericExec<TPgDirectFunc<&macaddr8_set7bit>, true, false, TArgs_macaddr8_set7bit_Policy>; }
-struct TArgs_macaddr8_trunc_Policy {
+TExecFunc arrow_int2larger() { return TGenericExec<TPgDirectFunc<&int2larger>, true, true, TArgs_int2larger_Policy>({}); }
+struct TArgs_int2le_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_macaddr8_trunc() { return &GenericExec<TPgDirectFunc<&macaddr8_trunc>, true, false, TArgs_macaddr8_trunc_Policy>; }
-struct TArgs_macaddr8tomacaddr_Policy {
+TExecFunc arrow_int2le() { return TGenericExec<TPgDirectFunc<&int2le>, true, true, TArgs_int2le_Policy>({}); }
+struct TArgs_int2lt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_macaddr8tomacaddr() { return &GenericExec<TPgDirectFunc<&macaddr8tomacaddr>, true, false, TArgs_macaddr8tomacaddr_Policy>; }
-struct TArgs_macaddrtomacaddr8_Policy {
+TExecFunc arrow_int2lt() { return TGenericExec<TPgDirectFunc<&int2lt>, true, true, TArgs_int2lt_Policy>({}); }
+struct TArgs_int2mi_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_macaddrtomacaddr8() { return &GenericExec<TPgDirectFunc<&macaddrtomacaddr8>, true, false, TArgs_macaddrtomacaddr8_Policy>; }
-struct TArgs_make_date_Policy {
+TExecFunc arrow_int2mi() { return TGenericExec<TPgDirectFunc<&int2mi>, true, true, TArgs_int2mi_Policy>({}); }
+struct TArgs_int2mod_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_make_date() { return &GenericExec<TPgDirectFunc<&make_date>, true, true, TArgs_make_date_Policy>; }
-struct TArgs_make_time_Policy {
+TExecFunc arrow_int2mod() { return TGenericExec<TPgDirectFunc<&int2mod>, true, true, TArgs_int2mod_Policy>({}); }
+struct TArgs_int2mul_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_make_time() { return &GenericExec<TPgDirectFunc<&make_time>, true, true, TArgs_make_time_Policy>; }
-struct TArgs_multirange_gist_compress_Policy {
+TExecFunc arrow_int2mul() { return TGenericExec<TPgDirectFunc<&int2mul>, true, true, TArgs_int2mul_Policy>({}); }
+struct TArgs_int2ne_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+};
+TExecFunc arrow_int2ne() { return TGenericExec<TPgDirectFunc<&int2ne>, true, true, TArgs_int2ne_Policy>({}); }
+struct TArgs_int2not_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_multirange_gist_compress() { return &GenericExec<TPgDirectFunc<&multirange_gist_compress>, true, true, TArgs_multirange_gist_compress_Policy>; }
-struct TArgs_multirange_gist_consistent_Policy {
+TExecFunc arrow_int2not() { return TGenericExec<TPgDirectFunc<&int2not>, true, true, TArgs_int2not_Policy>({}); }
+struct TArgs_int2or_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,false,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_multirange_gist_consistent() { return &GenericExec<TPgDirectFunc<&multirange_gist_consistent>, true, true, TArgs_multirange_gist_consistent_Policy>; }
-struct TArgs_mxid_age_Policy {
+TExecFunc arrow_int2or() { return TGenericExec<TPgDirectFunc<&int2or>, true, true, TArgs_int2or_Policy>({}); }
+struct TArgs_int2out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_mxid_age() { return &GenericExec<TPgDirectFunc<&mxid_age>, true, true, TArgs_mxid_age_Policy>; }
-struct TArgs_nameconcatoid_Policy {
+TExecFunc arrow_int2out() { return TGenericExec<TPgDirectFunc<&int2out>, true, false, TArgs_int2out_Policy>({}); }
+struct TArgs_int2pl_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_nameconcatoid() { return &GenericExec<TPgDirectFunc<&nameconcatoid>, true, false, TArgs_nameconcatoid_Policy>; }
-struct TArgs_nameeq_Policy {
+TExecFunc arrow_int2pl() { return TGenericExec<TPgDirectFunc<&int2pl>, true, true, TArgs_int2pl_Policy>({}); }
+struct TArgs_int2recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_nameeq() { return &GenericExec<TPgDirectFunc<&nameeq>, true, true, TArgs_nameeq_Policy>; }
-struct TArgs_namege_Policy {
+TExecFunc arrow_int2recv() { return TGenericExec<TPgDirectFunc<&int2recv>, true, true, TArgs_int2recv_Policy>({}); }
+struct TArgs_int2send_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_namege() { return &GenericExec<TPgDirectFunc<&namege>, true, true, TArgs_namege_Policy>; }
-struct TArgs_namegt_Policy {
+TExecFunc arrow_int2send() { return TGenericExec<TPgDirectFunc<&int2send>, true, false, TArgs_int2send_Policy>({}); }
+struct TArgs_int2shl_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_namegt() { return &GenericExec<TPgDirectFunc<&namegt>, true, true, TArgs_namegt_Policy>; }
-struct TArgs_namein_Policy {
+TExecFunc arrow_int2shl() { return TGenericExec<TPgDirectFunc<&int2shl>, true, true, TArgs_int2shl_Policy>({}); }
+struct TArgs_int2shr_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_namein() { return &GenericExec<TPgDirectFunc<&namein>, true, false, TArgs_namein_Policy>; }
-struct TArgs_namele_Policy {
+TExecFunc arrow_int2shr() { return TGenericExec<TPgDirectFunc<&int2shr>, true, true, TArgs_int2shr_Policy>({}); }
+struct TArgs_int2smaller_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_namele() { return &GenericExec<TPgDirectFunc<&namele>, true, true, TArgs_namele_Policy>; }
-struct TArgs_namelt_Policy {
+TExecFunc arrow_int2smaller() { return TGenericExec<TPgDirectFunc<&int2smaller>, true, true, TArgs_int2smaller_Policy>({}); }
+struct TArgs_int2um_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_namelt() { return &GenericExec<TPgDirectFunc<&namelt>, true, true, TArgs_namelt_Policy>; }
-struct TArgs_namene_Policy {
+TExecFunc arrow_int2um() { return TGenericExec<TPgDirectFunc<&int2um>, true, true, TArgs_int2um_Policy>({}); }
+struct TArgs_int2up_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_namene() { return &GenericExec<TPgDirectFunc<&namene>, true, true, TArgs_namene_Policy>; }
-struct TArgs_nameout_Policy {
+TExecFunc arrow_int2up() { return TGenericExec<TPgDirectFunc<&int2up>, true, true, TArgs_int2up_Policy>({}); }
+struct TArgs_int2vectorin_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_nameout() { return &GenericExec<TPgDirectFunc<&nameout>, true, false, TArgs_nameout_Policy>; }
-struct TArgs_namerecv_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_namerecv() { return &GenericExec<TPgDirectFunc<&namerecv>, true, false, TArgs_namerecv_Policy>; }
-struct TArgs_namesend_Policy {
+TExecFunc arrow_int2vectorin() { return TGenericExec<TPgDirectFunc<&int2vectorin>, true, false, TArgs_int2vectorin_Policy>({}); }
+struct TArgs_int2vectorout_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_namesend() { return &GenericExec<TPgDirectFunc<&namesend>, true, false, TArgs_namesend_Policy>; }
-struct TArgs_nextval_oid_Policy {
+TExecFunc arrow_int2vectorout() { return TGenericExec<TPgDirectFunc<&int2vectorout>, true, false, TArgs_int2vectorout_Policy>({}); }
+struct TArgs_int2vectorrecv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_nextval_oid() { return &GenericExec<TPgDirectFunc<&nextval_oid>, true, true, TArgs_nextval_oid_Policy>; }
-struct TArgs_numrange_subdiff_Policy {
+TExecFunc arrow_int2vectorrecv() { return TGenericExec<TPgDirectFunc<&int2vectorrecv>, true, false, TArgs_int2vectorrecv_Policy>({}); }
+struct TArgs_int2vectorsend_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_numrange_subdiff() { return &GenericExec<TPgDirectFunc<&numrange_subdiff>, true, true, TArgs_numrange_subdiff_Policy>; }
-struct TArgs_oidtoi8_Policy {
+TExecFunc arrow_int2vectorsend() { return TGenericExec<TPgDirectFunc<&int2vectorsend>, true, false, TArgs_int2vectorsend_Policy>({}); }
+struct TArgs_int2xor_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_oidtoi8() { return &GenericExec<TPgDirectFunc<&oidtoi8>, true, true, TArgs_oidtoi8_Policy>; }
-struct TArgs_overlaps_time_Policy {
+TExecFunc arrow_int2xor() { return TGenericExec<TPgDirectFunc<&int2xor>, true, true, TArgs_int2xor_Policy>({}); }
+struct TArgs_int42div_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_overlaps_time() { return &GenericExec<TPgDirectFunc<&overlaps_time>, false, true, TArgs_overlaps_time_Policy>; }
-struct TArgs_overlaps_timetz_Policy {
+TExecFunc arrow_int42div() { return TGenericExec<TPgDirectFunc<&int42div>, true, true, TArgs_int42div_Policy>({}); }
+struct TArgs_int42eq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_overlaps_timetz() { return &GenericExec<TPgDirectFunc<&overlaps_timetz>, false, true, TArgs_overlaps_timetz_Policy>; }
-struct TArgs_parse_ident_Policy {
+TExecFunc arrow_int42eq() { return TGenericExec<TPgDirectFunc<&int42eq>, true, true, TArgs_int42eq_Policy>({}); }
+struct TArgs_int42ge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_parse_ident() { return &GenericExec<TPgDirectFunc<&parse_ident>, true, false, TArgs_parse_ident_Policy>; }
-struct TArgs_pg_backend_pid_Policy {
+TExecFunc arrow_int42ge() { return TGenericExec<TPgDirectFunc<&int42ge>, true, true, TArgs_int42ge_Policy>({}); }
+struct TArgs_int42gt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_backend_pid() { return &GenericExec<TPgDirectFunc<&pg_backend_pid>, true, true, TArgs_pg_backend_pid_Policy>; }
-struct TArgs_pg_collation_actual_version_Policy {
+TExecFunc arrow_int42gt() { return TGenericExec<TPgDirectFunc<&int42gt>, true, true, TArgs_int42gt_Policy>({}); }
+struct TArgs_int42le_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_collation_actual_version() { return &GenericExec<TPgDirectFunc<&pg_collation_actual_version>, true, false, TArgs_pg_collation_actual_version_Policy>; }
-struct TArgs_pg_collation_for_Policy {
+TExecFunc arrow_int42le() { return TGenericExec<TPgDirectFunc<&int42le>, true, true, TArgs_int42le_Policy>({}); }
+struct TArgs_int42lt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_collation_for() { return &GenericExec<TPgDirectFunc<&pg_collation_for>, false, false, TArgs_pg_collation_for_Policy>; }
-struct TArgs_pg_column_is_updatable_Policy {
+TExecFunc arrow_int42lt() { return TGenericExec<TPgDirectFunc<&int42lt>, true, true, TArgs_int42lt_Policy>({}); }
+struct TArgs_int42mi_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_column_is_updatable() { return &GenericExec<TPgDirectFunc<&pg_column_is_updatable>, true, true, TArgs_pg_column_is_updatable_Policy>; }
-struct TArgs_pg_current_logfile_Policy {
+TExecFunc arrow_int42mi() { return TGenericExec<TPgDirectFunc<&int42mi>, true, true, TArgs_int42mi_Policy>({}); }
+struct TArgs_int42mul_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_current_logfile() { return &GenericExec<TPgDirectFunc<&pg_current_logfile>, false, false, TArgs_pg_current_logfile_Policy>; }
-struct TArgs_pg_current_logfile_1arg_Policy {
+TExecFunc arrow_int42mul() { return TGenericExec<TPgDirectFunc<&int42mul>, true, true, TArgs_int42mul_Policy>({}); }
+struct TArgs_int42ne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_current_logfile_1arg() { return &GenericExec<TPgDirectFunc<&pg_current_logfile_1arg>, false, false, TArgs_pg_current_logfile_1arg_Policy>; }
-struct TArgs_pg_database_size_name_Policy {
+TExecFunc arrow_int42ne() { return TGenericExec<TPgDirectFunc<&int42ne>, true, true, TArgs_int42ne_Policy>({}); }
+struct TArgs_int42pl_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_database_size_name() { return &GenericExec<TPgDirectFunc<&pg_database_size_name>, true, true, TArgs_pg_database_size_name_Policy>; }
-struct TArgs_pg_database_size_oid_Policy {
+TExecFunc arrow_int42pl() { return TGenericExec<TPgDirectFunc<&int42pl>, true, true, TArgs_int42pl_Policy>({}); }
+struct TArgs_int48_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_database_size_oid() { return &GenericExec<TPgDirectFunc<&pg_database_size_oid>, true, true, TArgs_pg_database_size_oid_Policy>; }
-struct TArgs_pg_filenode_relation_Policy {
+TExecFunc arrow_int48() { return TGenericExec<TPgDirectFunc<&int48>, true, true, TArgs_int48_Policy>({}); }
+struct TArgs_int48div_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_filenode_relation() { return &GenericExec<TPgDirectFunc<&pg_filenode_relation>, true, true, TArgs_pg_filenode_relation_Policy>; }
-struct TArgs_pg_get_constraintdef_Policy {
+TExecFunc arrow_int48div() { return TGenericExec<TPgDirectFunc<&int48div>, true, true, TArgs_int48div_Policy>({}); }
+struct TArgs_int48eq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_get_constraintdef() { return &GenericExec<TPgDirectFunc<&pg_get_constraintdef>, true, false, TArgs_pg_get_constraintdef_Policy>; }
-struct TArgs_pg_get_constraintdef_ext_Policy {
+TExecFunc arrow_int48eq() { return TGenericExec<TPgDirectFunc<&int48eq>, true, true, TArgs_int48eq_Policy>({}); }
+struct TArgs_int48ge_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_get_constraintdef_ext() { return &GenericExec<TPgDirectFunc<&pg_get_constraintdef_ext>, true, false, TArgs_pg_get_constraintdef_ext_Policy>; }
-struct TArgs_pg_get_expr_Policy {
+TExecFunc arrow_int48ge() { return TGenericExec<TPgDirectFunc<&int48ge>, true, true, TArgs_int48ge_Policy>({}); }
+struct TArgs_int48gt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_get_expr() { return &GenericExec<TPgDirectFunc<&pg_get_expr>, true, false, TArgs_pg_get_expr_Policy>; }
-struct TArgs_pg_get_expr_ext_Policy {
+TExecFunc arrow_int48gt() { return TGenericExec<TPgDirectFunc<&int48gt>, true, true, TArgs_int48gt_Policy>({}); }
+struct TArgs_int48le_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_get_expr_ext() { return &GenericExec<TPgDirectFunc<&pg_get_expr_ext>, true, false, TArgs_pg_get_expr_ext_Policy>; }
-struct TArgs_pg_get_function_arg_default_Policy {
+TExecFunc arrow_int48le() { return TGenericExec<TPgDirectFunc<&int48le>, true, true, TArgs_int48le_Policy>({}); }
+struct TArgs_int48lt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_get_function_arg_default() { return &GenericExec<TPgDirectFunc<&pg_get_function_arg_default>, true, false, TArgs_pg_get_function_arg_default_Policy>; }
-struct TArgs_pg_get_function_arguments_Policy {
+TExecFunc arrow_int48lt() { return TGenericExec<TPgDirectFunc<&int48lt>, true, true, TArgs_int48lt_Policy>({}); }
+struct TArgs_int48mi_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_get_function_arguments() { return &GenericExec<TPgDirectFunc<&pg_get_function_arguments>, true, false, TArgs_pg_get_function_arguments_Policy>; }
-struct TArgs_pg_get_function_identity_arguments_Policy {
+TExecFunc arrow_int48mi() { return TGenericExec<TPgDirectFunc<&int48mi>, true, true, TArgs_int48mi_Policy>({}); }
+struct TArgs_int48mul_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_get_function_identity_arguments() { return &GenericExec<TPgDirectFunc<&pg_get_function_identity_arguments>, true, false, TArgs_pg_get_function_identity_arguments_Policy>; }
-struct TArgs_pg_get_function_result_Policy {
+TExecFunc arrow_int48mul() { return TGenericExec<TPgDirectFunc<&int48mul>, true, true, TArgs_int48mul_Policy>({}); }
+struct TArgs_int48ne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_get_function_result() { return &GenericExec<TPgDirectFunc<&pg_get_function_result>, true, false, TArgs_pg_get_function_result_Policy>; }
-struct TArgs_pg_get_function_sqlbody_Policy {
+TExecFunc arrow_int48ne() { return TGenericExec<TPgDirectFunc<&int48ne>, true, true, TArgs_int48ne_Policy>({}); }
+struct TArgs_int48pl_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_get_function_sqlbody() { return &GenericExec<TPgDirectFunc<&pg_get_function_sqlbody>, true, false, TArgs_pg_get_function_sqlbody_Policy>; }
-struct TArgs_pg_get_functiondef_Policy {
+TExecFunc arrow_int48pl() { return TGenericExec<TPgDirectFunc<&int48pl>, true, true, TArgs_int48pl_Policy>({}); }
+struct TArgs_int4_bool_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_get_functiondef() { return &GenericExec<TPgDirectFunc<&pg_get_functiondef>, true, false, TArgs_pg_get_functiondef_Policy>; }
-struct TArgs_pg_get_indexdef_Policy {
+TExecFunc arrow_int4_bool() { return TGenericExec<TPgDirectFunc<&int4_bool>, true, true, TArgs_int4_bool_Policy>({}); }
+struct TArgs_int4abs_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_get_indexdef() { return &GenericExec<TPgDirectFunc<&pg_get_indexdef>, true, false, TArgs_pg_get_indexdef_Policy>; }
-struct TArgs_pg_get_indexdef_ext_Policy {
+TExecFunc arrow_int4abs() { return TGenericExec<TPgDirectFunc<&int4abs>, true, true, TArgs_int4abs_Policy>({}); }
+struct TArgs_int4and_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_get_indexdef_ext() { return &GenericExec<TPgDirectFunc<&pg_get_indexdef_ext>, true, false, TArgs_pg_get_indexdef_ext_Policy>; }
-struct TArgs_pg_get_partition_constraintdef_Policy {
+TExecFunc arrow_int4and() { return TGenericExec<TPgDirectFunc<&int4and>, true, true, TArgs_int4and_Policy>({}); }
+struct TArgs_int4div_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_get_partition_constraintdef() { return &GenericExec<TPgDirectFunc<&pg_get_partition_constraintdef>, true, false, TArgs_pg_get_partition_constraintdef_Policy>; }
-struct TArgs_pg_get_partkeydef_Policy {
+TExecFunc arrow_int4div() { return TGenericExec<TPgDirectFunc<&int4div>, true, true, TArgs_int4div_Policy>({}); }
+struct TArgs_int4eq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_get_partkeydef() { return &GenericExec<TPgDirectFunc<&pg_get_partkeydef>, true, false, TArgs_pg_get_partkeydef_Policy>; }
-struct TArgs_pg_get_replica_identity_index_Policy {
+TExecFunc arrow_int4eq() { return TGenericExec<TPgDirectFunc<&int4eq>, true, true, TArgs_int4eq_Policy>({}); }
+struct TArgs_int4gcd_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_get_replica_identity_index() { return &GenericExec<TPgDirectFunc<&pg_get_replica_identity_index>, true, true, TArgs_pg_get_replica_identity_index_Policy>; }
-struct TArgs_pg_get_ruledef_Policy {
+TExecFunc arrow_int4gcd() { return TGenericExec<TPgDirectFunc<&int4gcd>, true, true, TArgs_int4gcd_Policy>({}); }
+struct TArgs_int4ge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_get_ruledef() { return &GenericExec<TPgDirectFunc<&pg_get_ruledef>, true, false, TArgs_pg_get_ruledef_Policy>; }
-struct TArgs_pg_get_ruledef_ext_Policy {
+TExecFunc arrow_int4ge() { return TGenericExec<TPgDirectFunc<&int4ge>, true, true, TArgs_int4ge_Policy>({}); }
+struct TArgs_int4gt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_get_ruledef_ext() { return &GenericExec<TPgDirectFunc<&pg_get_ruledef_ext>, true, false, TArgs_pg_get_ruledef_ext_Policy>; }
-struct TArgs_pg_get_serial_sequence_Policy {
+TExecFunc arrow_int4gt() { return TGenericExec<TPgDirectFunc<&int4gt>, true, true, TArgs_int4gt_Policy>({}); }
+struct TArgs_int4in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_get_serial_sequence() { return &GenericExec<TPgDirectFunc<&pg_get_serial_sequence>, true, false, TArgs_pg_get_serial_sequence_Policy>; }
-struct TArgs_pg_get_statisticsobjdef_Policy {
+TExecFunc arrow_int4in() { return TGenericExec<TPgDirectFunc<&int4in>, true, true, TArgs_int4in_Policy>({}); }
+struct TArgs_int4inc_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_get_statisticsobjdef() { return &GenericExec<TPgDirectFunc<&pg_get_statisticsobjdef>, true, false, TArgs_pg_get_statisticsobjdef_Policy>; }
-struct TArgs_pg_get_statisticsobjdef_columns_Policy {
+TExecFunc arrow_int4inc() { return TGenericExec<TPgDirectFunc<&int4inc>, true, true, TArgs_int4inc_Policy>({}); }
+struct TArgs_int4larger_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_get_statisticsobjdef_columns() { return &GenericExec<TPgDirectFunc<&pg_get_statisticsobjdef_columns>, true, false, TArgs_pg_get_statisticsobjdef_columns_Policy>; }
-struct TArgs_pg_get_statisticsobjdef_expressions_Policy {
+TExecFunc arrow_int4larger() { return TGenericExec<TPgDirectFunc<&int4larger>, true, true, TArgs_int4larger_Policy>({}); }
+struct TArgs_int4lcm_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_get_statisticsobjdef_expressions() { return &GenericExec<TPgDirectFunc<&pg_get_statisticsobjdef_expressions>, true, false, TArgs_pg_get_statisticsobjdef_expressions_Policy>; }
-struct TArgs_pg_get_triggerdef_Policy {
+TExecFunc arrow_int4lcm() { return TGenericExec<TPgDirectFunc<&int4lcm>, true, true, TArgs_int4lcm_Policy>({}); }
+struct TArgs_int4le_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_get_triggerdef() { return &GenericExec<TPgDirectFunc<&pg_get_triggerdef>, true, false, TArgs_pg_get_triggerdef_Policy>; }
-struct TArgs_pg_get_triggerdef_ext_Policy {
+TExecFunc arrow_int4le() { return TGenericExec<TPgDirectFunc<&int4le>, true, true, TArgs_int4le_Policy>({}); }
+struct TArgs_int4lt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_get_triggerdef_ext() { return &GenericExec<TPgDirectFunc<&pg_get_triggerdef_ext>, true, false, TArgs_pg_get_triggerdef_ext_Policy>; }
-struct TArgs_pg_get_userbyid_Policy {
+TExecFunc arrow_int4lt() { return TGenericExec<TPgDirectFunc<&int4lt>, true, true, TArgs_int4lt_Policy>({}); }
+struct TArgs_int4mi_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_get_userbyid() { return &GenericExec<TPgDirectFunc<&pg_get_userbyid>, true, false, TArgs_pg_get_userbyid_Policy>; }
-struct TArgs_pg_get_viewdef_Policy {
+TExecFunc arrow_int4mi() { return TGenericExec<TPgDirectFunc<&int4mi>, true, true, TArgs_int4mi_Policy>({}); }
+struct TArgs_int4mod_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_get_viewdef() { return &GenericExec<TPgDirectFunc<&pg_get_viewdef>, true, false, TArgs_pg_get_viewdef_Policy>; }
-struct TArgs_pg_get_viewdef_ext_Policy {
+TExecFunc arrow_int4mod() { return TGenericExec<TPgDirectFunc<&int4mod>, true, true, TArgs_int4mod_Policy>({}); }
+struct TArgs_int4mul_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_get_viewdef_ext() { return &GenericExec<TPgDirectFunc<&pg_get_viewdef_ext>, true, false, TArgs_pg_get_viewdef_ext_Policy>; }
-struct TArgs_pg_get_viewdef_name_Policy {
+TExecFunc arrow_int4mul() { return TGenericExec<TPgDirectFunc<&int4mul>, true, true, TArgs_int4mul_Policy>({}); }
+struct TArgs_int4ne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_get_viewdef_name() { return &GenericExec<TPgDirectFunc<&pg_get_viewdef_name>, true, false, TArgs_pg_get_viewdef_name_Policy>; }
-struct TArgs_pg_get_viewdef_name_ext_Policy {
+TExecFunc arrow_int4ne() { return TGenericExec<TPgDirectFunc<&int4ne>, true, true, TArgs_int4ne_Policy>({}); }
+struct TArgs_int4not_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_get_viewdef_name_ext() { return &GenericExec<TPgDirectFunc<&pg_get_viewdef_name_ext>, true, false, TArgs_pg_get_viewdef_name_ext_Policy>; }
-struct TArgs_pg_get_viewdef_wrap_Policy {
+TExecFunc arrow_int4not() { return TGenericExec<TPgDirectFunc<&int4not>, true, true, TArgs_int4not_Policy>({}); }
+struct TArgs_int4or_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_get_viewdef_wrap() { return &GenericExec<TPgDirectFunc<&pg_get_viewdef_wrap>, true, false, TArgs_pg_get_viewdef_wrap_Policy>; }
-struct TArgs_pg_import_system_collations_Policy {
+TExecFunc arrow_int4or() { return TGenericExec<TPgDirectFunc<&int4or>, true, true, TArgs_int4or_Policy>({}); }
+struct TArgs_int4out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_import_system_collations() { return &GenericExec<TPgDirectFunc<&pg_import_system_collations>, true, true, TArgs_pg_import_system_collations_Policy>; }
-struct TArgs_pg_indexes_size_Policy {
+TExecFunc arrow_int4out() { return TGenericExec<TPgDirectFunc<&int4out>, true, false, TArgs_int4out_Policy>({}); }
+struct TArgs_int4pl_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+};
+TExecFunc arrow_int4pl() { return TGenericExec<TPgDirectFunc<&int4pl>, true, true, TArgs_int4pl_Policy>({}); }
+struct TArgs_int4recv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_indexes_size() { return &GenericExec<TPgDirectFunc<&pg_indexes_size>, true, true, TArgs_pg_indexes_size_Policy>; }
-struct TArgs_pg_log_backend_memory_contexts_Policy {
+TExecFunc arrow_int4recv() { return TGenericExec<TPgDirectFunc<&int4recv>, true, true, TArgs_int4recv_Policy>({}); }
+struct TArgs_int4send_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_log_backend_memory_contexts() { return &GenericExec<TPgDirectFunc<&pg_log_backend_memory_contexts>, true, true, TArgs_pg_log_backend_memory_contexts_Policy>; }
-struct TArgs_pg_mcv_list_in_Policy {
+TExecFunc arrow_int4send() { return TGenericExec<TPgDirectFunc<&int4send>, true, false, TArgs_int4send_Policy>({}); }
+struct TArgs_int4shl_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_mcv_list_in() { return &GenericExec<TPgDirectFunc<&pg_mcv_list_in>, true, false, TArgs_pg_mcv_list_in_Policy>; }
-struct TArgs_pg_mcv_list_out_Policy {
+TExecFunc arrow_int4shl() { return TGenericExec<TPgDirectFunc<&int4shl>, true, true, TArgs_int4shl_Policy>({}); }
+struct TArgs_int4shr_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_mcv_list_out() { return &GenericExec<TPgDirectFunc<&pg_mcv_list_out>, true, false, TArgs_pg_mcv_list_out_Policy>; }
-struct TArgs_pg_mcv_list_recv_Policy {
+TExecFunc arrow_int4shr() { return TGenericExec<TPgDirectFunc<&int4shr>, true, true, TArgs_int4shr_Policy>({}); }
+struct TArgs_int4smaller_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_mcv_list_recv() { return &GenericExec<TPgDirectFunc<&pg_mcv_list_recv>, true, false, TArgs_pg_mcv_list_recv_Policy>; }
-struct TArgs_pg_mcv_list_send_Policy {
+TExecFunc arrow_int4smaller() { return TGenericExec<TPgDirectFunc<&int4smaller>, true, true, TArgs_int4smaller_Policy>({}); }
+struct TArgs_int4um_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_mcv_list_send() { return &GenericExec<TPgDirectFunc<&pg_mcv_list_send>, true, false, TArgs_pg_mcv_list_send_Policy>; }
-struct TArgs_pg_ndistinct_in_Policy {
+TExecFunc arrow_int4um() { return TGenericExec<TPgDirectFunc<&int4um>, true, true, TArgs_int4um_Policy>({}); }
+struct TArgs_int4up_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_ndistinct_in() { return &GenericExec<TPgDirectFunc<&pg_ndistinct_in>, true, false, TArgs_pg_ndistinct_in_Policy>; }
-struct TArgs_pg_ndistinct_out_Policy {
+TExecFunc arrow_int4up() { return TGenericExec<TPgDirectFunc<&int4up>, true, true, TArgs_int4up_Policy>({}); }
+struct TArgs_int4xor_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_ndistinct_out() { return &GenericExec<TPgDirectFunc<&pg_ndistinct_out>, true, false, TArgs_pg_ndistinct_out_Policy>; }
-struct TArgs_pg_ndistinct_recv_Policy {
+TExecFunc arrow_int4xor() { return TGenericExec<TPgDirectFunc<&int4xor>, true, true, TArgs_int4xor_Policy>({}); }
+struct TArgs_int82_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_ndistinct_recv() { return &GenericExec<TPgDirectFunc<&pg_ndistinct_recv>, true, false, TArgs_pg_ndistinct_recv_Policy>; }
-struct TArgs_pg_ndistinct_send_Policy {
+TExecFunc arrow_int82() { return TGenericExec<TPgDirectFunc<&int82>, true, true, TArgs_int82_Policy>({}); }
+struct TArgs_int82div_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_ndistinct_send() { return &GenericExec<TPgDirectFunc<&pg_ndistinct_send>, true, false, TArgs_pg_ndistinct_send_Policy>; }
-struct TArgs_pg_read_binary_file_Policy {
+TExecFunc arrow_int82div() { return TGenericExec<TPgDirectFunc<&int82div>, true, true, TArgs_int82div_Policy>({}); }
+struct TArgs_int82eq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_read_binary_file() { return &GenericExec<TPgDirectFunc<&pg_read_binary_file>, true, false, TArgs_pg_read_binary_file_Policy>; }
-struct TArgs_pg_read_binary_file_all_Policy {
+TExecFunc arrow_int82eq() { return TGenericExec<TPgDirectFunc<&int82eq>, true, true, TArgs_int82eq_Policy>({}); }
+struct TArgs_int82ge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_read_binary_file_all() { return &GenericExec<TPgDirectFunc<&pg_read_binary_file_all>, true, false, TArgs_pg_read_binary_file_all_Policy>; }
-struct TArgs_pg_read_binary_file_off_len_Policy {
+TExecFunc arrow_int82ge() { return TGenericExec<TPgDirectFunc<&int82ge>, true, true, TArgs_int82ge_Policy>({}); }
+struct TArgs_int82gt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_read_binary_file_off_len() { return &GenericExec<TPgDirectFunc<&pg_read_binary_file_off_len>, true, false, TArgs_pg_read_binary_file_off_len_Policy>; }
-struct TArgs_pg_read_file_Policy {
+TExecFunc arrow_int82gt() { return TGenericExec<TPgDirectFunc<&int82gt>, true, true, TArgs_int82gt_Policy>({}); }
+struct TArgs_int82le_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_read_file() { return &GenericExec<TPgDirectFunc<&pg_read_file>, true, false, TArgs_pg_read_file_Policy>; }
-struct TArgs_pg_read_file_all_Policy {
+TExecFunc arrow_int82le() { return TGenericExec<TPgDirectFunc<&int82le>, true, true, TArgs_int82le_Policy>({}); }
+struct TArgs_int82lt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_read_file_all() { return &GenericExec<TPgDirectFunc<&pg_read_file_all>, true, false, TArgs_pg_read_file_all_Policy>; }
-struct TArgs_pg_read_file_off_len_Policy {
+TExecFunc arrow_int82lt() { return TGenericExec<TPgDirectFunc<&int82lt>, true, true, TArgs_int82lt_Policy>({}); }
+struct TArgs_int82mi_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_read_file_off_len() { return &GenericExec<TPgDirectFunc<&pg_read_file_off_len>, true, false, TArgs_pg_read_file_off_len_Policy>; }
-struct TArgs_pg_read_file_v2_Policy {
+TExecFunc arrow_int82mi() { return TGenericExec<TPgDirectFunc<&int82mi>, true, true, TArgs_int82mi_Policy>({}); }
+struct TArgs_int82mul_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_read_file_v2() { return &GenericExec<TPgDirectFunc<&pg_read_file_v2>, true, false, TArgs_pg_read_file_v2_Policy>; }
-struct TArgs_pg_relation_filenode_Policy {
+TExecFunc arrow_int82mul() { return TGenericExec<TPgDirectFunc<&int82mul>, true, true, TArgs_int82mul_Policy>({}); }
+struct TArgs_int82ne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+};
+TExecFunc arrow_int82ne() { return TGenericExec<TPgDirectFunc<&int82ne>, true, true, TArgs_int82ne_Policy>({}); }
+struct TArgs_int82pl_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_relation_filenode() { return &GenericExec<TPgDirectFunc<&pg_relation_filenode>, true, true, TArgs_pg_relation_filenode_Policy>; }
-struct TArgs_pg_relation_filepath_Policy {
+TExecFunc arrow_int82pl() { return TGenericExec<TPgDirectFunc<&int82pl>, true, true, TArgs_int82pl_Policy>({}); }
+struct TArgs_int84_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_relation_filepath() { return &GenericExec<TPgDirectFunc<&pg_relation_filepath>, true, false, TArgs_pg_relation_filepath_Policy>; }
-struct TArgs_pg_relation_is_updatable_Policy {
+TExecFunc arrow_int84() { return TGenericExec<TPgDirectFunc<&int84>, true, true, TArgs_int84_Policy>({}); }
+struct TArgs_int84div_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_relation_is_updatable() { return &GenericExec<TPgDirectFunc<&pg_relation_is_updatable>, true, true, TArgs_pg_relation_is_updatable_Policy>; }
-struct TArgs_pg_relation_size_Policy {
+TExecFunc arrow_int84div() { return TGenericExec<TPgDirectFunc<&int84div>, true, true, TArgs_int84div_Policy>({}); }
+struct TArgs_int84eq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_relation_size() { return &GenericExec<TPgDirectFunc<&pg_relation_size>, true, true, TArgs_pg_relation_size_Policy>; }
-struct TArgs_pg_replication_origin_advance_Policy {
+TExecFunc arrow_int84eq() { return TGenericExec<TPgDirectFunc<&int84eq>, true, true, TArgs_int84eq_Policy>({}); }
+struct TArgs_int84ge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_replication_origin_advance() { return &GenericExec<TPgDirectFunc<&pg_replication_origin_advance>, true, true, TArgs_pg_replication_origin_advance_Policy>; }
-struct TArgs_pg_replication_origin_create_Policy {
+TExecFunc arrow_int84ge() { return TGenericExec<TPgDirectFunc<&int84ge>, true, true, TArgs_int84ge_Policy>({}); }
+struct TArgs_int84gt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_replication_origin_create() { return &GenericExec<TPgDirectFunc<&pg_replication_origin_create>, true, true, TArgs_pg_replication_origin_create_Policy>; }
-struct TArgs_pg_replication_origin_drop_Policy {
+TExecFunc arrow_int84gt() { return TGenericExec<TPgDirectFunc<&int84gt>, true, true, TArgs_int84gt_Policy>({}); }
+struct TArgs_int84le_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_replication_origin_drop() { return &GenericExec<TPgDirectFunc<&pg_replication_origin_drop>, true, true, TArgs_pg_replication_origin_drop_Policy>; }
-struct TArgs_pg_replication_origin_oid_Policy {
+TExecFunc arrow_int84le() { return TGenericExec<TPgDirectFunc<&int84le>, true, true, TArgs_int84le_Policy>({}); }
+struct TArgs_int84lt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_replication_origin_oid() { return &GenericExec<TPgDirectFunc<&pg_replication_origin_oid>, true, true, TArgs_pg_replication_origin_oid_Policy>; }
-struct TArgs_pg_replication_origin_progress_Policy {
+TExecFunc arrow_int84lt() { return TGenericExec<TPgDirectFunc<&int84lt>, true, true, TArgs_int84lt_Policy>({}); }
+struct TArgs_int84mi_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_replication_origin_progress() { return &GenericExec<TPgDirectFunc<&pg_replication_origin_progress>, true, true, TArgs_pg_replication_origin_progress_Policy>; }
-struct TArgs_pg_replication_origin_session_is_setup_Policy {
+TExecFunc arrow_int84mi() { return TGenericExec<TPgDirectFunc<&int84mi>, true, true, TArgs_int84mi_Policy>({}); }
+struct TArgs_int84mul_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+};
+TExecFunc arrow_int84mul() { return TGenericExec<TPgDirectFunc<&int84mul>, true, true, TArgs_int84mul_Policy>({}); }
+struct TArgs_int84ne_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+};
+TExecFunc arrow_int84ne() { return TGenericExec<TPgDirectFunc<&int84ne>, true, true, TArgs_int84ne_Policy>({}); }
+struct TArgs_int84pl_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+};
+TExecFunc arrow_int84pl() { return TGenericExec<TPgDirectFunc<&int84pl>, true, true, TArgs_int84pl_Policy>({}); }
+struct TArgs_int8abs_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_int8abs() { return TGenericExec<TPgDirectFunc<&int8abs>, true, true, TArgs_int8abs_Policy>({}); }
+struct TArgs_int8and_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_replication_origin_session_is_setup() { return &GenericExec<TPgDirectFunc<&pg_replication_origin_session_is_setup>, true, true, TArgs_pg_replication_origin_session_is_setup_Policy>; }
-struct TArgs_pg_replication_origin_session_progress_Policy {
+TExecFunc arrow_int8and() { return TGenericExec<TPgDirectFunc<&int8and>, true, true, TArgs_int8and_Policy>({}); }
+struct TArgs_int8dec_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_replication_origin_session_progress() { return &GenericExec<TPgDirectFunc<&pg_replication_origin_session_progress>, true, true, TArgs_pg_replication_origin_session_progress_Policy>; }
-struct TArgs_pg_replication_origin_session_reset_Policy {
+TExecFunc arrow_int8dec() { return TGenericExec<TPgDirectFunc<&int8dec>, true, true, TArgs_int8dec_Policy>({}); }
+struct TArgs_int8dec_any_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_replication_origin_session_reset() { return &GenericExec<TPgDirectFunc<&pg_replication_origin_session_reset>, true, true, TArgs_pg_replication_origin_session_reset_Policy>; }
-struct TArgs_pg_replication_origin_session_setup_Policy {
+TExecFunc arrow_int8dec_any() { return TGenericExec<TPgDirectFunc<&int8dec_any>, true, true, TArgs_int8dec_any_Policy>({}); }
+struct TArgs_int8div_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_replication_origin_session_setup() { return &GenericExec<TPgDirectFunc<&pg_replication_origin_session_setup>, true, true, TArgs_pg_replication_origin_session_setup_Policy>; }
-struct TArgs_pg_replication_origin_xact_reset_Policy {
+TExecFunc arrow_int8div() { return TGenericExec<TPgDirectFunc<&int8div>, true, true, TArgs_int8div_Policy>({}); }
+struct TArgs_int8eq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_replication_origin_xact_reset() { return &GenericExec<TPgDirectFunc<&pg_replication_origin_xact_reset>, true, true, TArgs_pg_replication_origin_xact_reset_Policy>; }
-struct TArgs_pg_replication_origin_xact_setup_Policy {
+TExecFunc arrow_int8eq() { return TGenericExec<TPgDirectFunc<&int8eq>, true, true, TArgs_int8eq_Policy>({}); }
+struct TArgs_int8gcd_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_replication_origin_xact_setup() { return &GenericExec<TPgDirectFunc<&pg_replication_origin_xact_setup>, true, true, TArgs_pg_replication_origin_xact_setup_Policy>; }
-struct TArgs_pg_sequence_last_value_Policy {
+TExecFunc arrow_int8gcd() { return TGenericExec<TPgDirectFunc<&int8gcd>, true, true, TArgs_int8gcd_Policy>({}); }
+struct TArgs_int8ge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_sequence_last_value() { return &GenericExec<TPgDirectFunc<&pg_sequence_last_value>, true, true, TArgs_pg_sequence_last_value_Policy>; }
-struct TArgs_pg_sequence_parameters_Policy {
+TExecFunc arrow_int8ge() { return TGenericExec<TPgDirectFunc<&int8ge>, true, true, TArgs_int8ge_Policy>({}); }
+struct TArgs_int8gt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_sequence_parameters() { return &GenericExec<TPgDirectFunc<&pg_sequence_parameters>, true, false, TArgs_pg_sequence_parameters_Policy>; }
-struct TArgs_pg_size_bytes_Policy {
+TExecFunc arrow_int8gt() { return TGenericExec<TPgDirectFunc<&int8gt>, true, true, TArgs_int8gt_Policy>({}); }
+struct TArgs_int8in_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_size_bytes() { return &GenericExec<TPgDirectFunc<&pg_size_bytes>, true, true, TArgs_pg_size_bytes_Policy>; }
-struct TArgs_pg_size_pretty_Policy {
+TExecFunc arrow_int8in() { return TGenericExec<TPgDirectFunc<&int8in>, true, true, TArgs_int8in_Policy>({}); }
+struct TArgs_int8inc_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_size_pretty() { return &GenericExec<TPgDirectFunc<&pg_size_pretty>, true, false, TArgs_pg_size_pretty_Policy>; }
-struct TArgs_pg_size_pretty_numeric_Policy {
+TExecFunc arrow_int8inc() { return TGenericExec<TPgDirectFunc<&int8inc>, true, true, TArgs_int8inc_Policy>({}); }
+struct TArgs_int8inc_any_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_size_pretty_numeric() { return &GenericExec<TPgDirectFunc<&pg_size_pretty_numeric>, true, false, TArgs_pg_size_pretty_numeric_Policy>; }
-struct TArgs_pg_sleep_Policy {
+TExecFunc arrow_int8inc_any() { return TGenericExec<TPgDirectFunc<&int8inc_any>, true, true, TArgs_int8inc_any_Policy>({}); }
+struct TArgs_int8inc_float8_float8_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_pg_sleep() { return &GenericExec<TPgDirectFunc<&pg_sleep>, true, true, TArgs_pg_sleep_Policy>; }
-struct TArgs_pg_stat_clear_snapshot_Policy {
+TExecFunc arrow_int8inc_float8_float8() { return TGenericExec<TPgDirectFunc<&int8inc_float8_float8>, true, true, TArgs_int8inc_float8_float8_Policy>({}); }
+struct TArgs_int8larger_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_stat_clear_snapshot() { return &GenericExec<TPgDirectFunc<&pg_stat_clear_snapshot>, false, true, TArgs_pg_stat_clear_snapshot_Policy>; }
-struct TArgs_pg_stat_file_Policy {
+TExecFunc arrow_int8larger() { return TGenericExec<TPgDirectFunc<&int8larger>, true, true, TArgs_int8larger_Policy>({}); }
+struct TArgs_int8lcm_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_stat_file() { return &GenericExec<TPgDirectFunc<&pg_stat_file>, true, false, TArgs_pg_stat_file_Policy>; }
-struct TArgs_pg_stat_file_1arg_Policy {
+TExecFunc arrow_int8lcm() { return TGenericExec<TPgDirectFunc<&int8lcm>, true, true, TArgs_int8lcm_Policy>({}); }
+struct TArgs_int8le_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_stat_file_1arg() { return &GenericExec<TPgDirectFunc<&pg_stat_file_1arg>, true, false, TArgs_pg_stat_file_1arg_Policy>; }
-struct TArgs_pg_stat_get_analyze_count_Policy {
+TExecFunc arrow_int8le() { return TGenericExec<TPgDirectFunc<&int8le>, true, true, TArgs_int8le_Policy>({}); }
+struct TArgs_int8lt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_stat_get_analyze_count() { return &GenericExec<TPgDirectFunc<&pg_stat_get_analyze_count>, true, true, TArgs_pg_stat_get_analyze_count_Policy>; }
-struct TArgs_pg_stat_get_archiver_Policy {
+TExecFunc arrow_int8lt() { return TGenericExec<TPgDirectFunc<&int8lt>, true, true, TArgs_int8lt_Policy>({}); }
+struct TArgs_int8mi_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_stat_get_archiver() { return &GenericExec<TPgDirectFunc<&pg_stat_get_archiver>, false, false, TArgs_pg_stat_get_archiver_Policy>; }
-struct TArgs_pg_stat_get_autoanalyze_count_Policy {
+TExecFunc arrow_int8mi() { return TGenericExec<TPgDirectFunc<&int8mi>, true, true, TArgs_int8mi_Policy>({}); }
+struct TArgs_int8mod_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_stat_get_autoanalyze_count() { return &GenericExec<TPgDirectFunc<&pg_stat_get_autoanalyze_count>, true, true, TArgs_pg_stat_get_autoanalyze_count_Policy>; }
-struct TArgs_pg_stat_get_autovacuum_count_Policy {
+TExecFunc arrow_int8mod() { return TGenericExec<TPgDirectFunc<&int8mod>, true, true, TArgs_int8mod_Policy>({}); }
+struct TArgs_int8mul_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_stat_get_autovacuum_count() { return &GenericExec<TPgDirectFunc<&pg_stat_get_autovacuum_count>, true, true, TArgs_pg_stat_get_autovacuum_count_Policy>; }
-struct TArgs_pg_stat_get_backend_activity_Policy {
+TExecFunc arrow_int8mul() { return TGenericExec<TPgDirectFunc<&int8mul>, true, true, TArgs_int8mul_Policy>({}); }
+struct TArgs_int8ne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_stat_get_backend_activity() { return &GenericExec<TPgDirectFunc<&pg_stat_get_backend_activity>, true, false, TArgs_pg_stat_get_backend_activity_Policy>; }
-struct TArgs_pg_stat_get_backend_activity_start_Policy {
+TExecFunc arrow_int8ne() { return TGenericExec<TPgDirectFunc<&int8ne>, true, true, TArgs_int8ne_Policy>({}); }
+struct TArgs_int8not_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_stat_get_backend_activity_start() { return &GenericExec<TPgDirectFunc<&pg_stat_get_backend_activity_start>, true, true, TArgs_pg_stat_get_backend_activity_start_Policy>; }
-struct TArgs_pg_stat_get_backend_client_addr_Policy {
+TExecFunc arrow_int8not() { return TGenericExec<TPgDirectFunc<&int8not>, true, true, TArgs_int8not_Policy>({}); }
+struct TArgs_int8or_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_stat_get_backend_client_addr() { return &GenericExec<TPgDirectFunc<&pg_stat_get_backend_client_addr>, true, false, TArgs_pg_stat_get_backend_client_addr_Policy>; }
-struct TArgs_pg_stat_get_backend_client_port_Policy {
+TExecFunc arrow_int8or() { return TGenericExec<TPgDirectFunc<&int8or>, true, true, TArgs_int8or_Policy>({}); }
+struct TArgs_int8out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_stat_get_backend_client_port() { return &GenericExec<TPgDirectFunc<&pg_stat_get_backend_client_port>, true, true, TArgs_pg_stat_get_backend_client_port_Policy>; }
-struct TArgs_pg_stat_get_backend_dbid_Policy {
+TExecFunc arrow_int8out() { return TGenericExec<TPgDirectFunc<&int8out>, true, false, TArgs_int8out_Policy>({}); }
+struct TArgs_int8pl_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_stat_get_backend_dbid() { return &GenericExec<TPgDirectFunc<&pg_stat_get_backend_dbid>, true, true, TArgs_pg_stat_get_backend_dbid_Policy>; }
-struct TArgs_pg_stat_get_backend_pid_Policy {
+TExecFunc arrow_int8pl() { return TGenericExec<TPgDirectFunc<&int8pl>, true, true, TArgs_int8pl_Policy>({}); }
+struct TArgs_int8recv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_stat_get_backend_pid() { return &GenericExec<TPgDirectFunc<&pg_stat_get_backend_pid>, true, true, TArgs_pg_stat_get_backend_pid_Policy>; }
-struct TArgs_pg_stat_get_backend_start_Policy {
+TExecFunc arrow_int8recv() { return TGenericExec<TPgDirectFunc<&int8recv>, true, true, TArgs_int8recv_Policy>({}); }
+struct TArgs_int8send_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_stat_get_backend_start() { return &GenericExec<TPgDirectFunc<&pg_stat_get_backend_start>, true, true, TArgs_pg_stat_get_backend_start_Policy>; }
-struct TArgs_pg_stat_get_backend_userid_Policy {
+TExecFunc arrow_int8send() { return TGenericExec<TPgDirectFunc<&int8send>, true, false, TArgs_int8send_Policy>({}); }
+struct TArgs_int8shl_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_stat_get_backend_userid() { return &GenericExec<TPgDirectFunc<&pg_stat_get_backend_userid>, true, true, TArgs_pg_stat_get_backend_userid_Policy>; }
-struct TArgs_pg_stat_get_backend_wait_event_Policy {
+TExecFunc arrow_int8shl() { return TGenericExec<TPgDirectFunc<&int8shl>, true, true, TArgs_int8shl_Policy>({}); }
+struct TArgs_int8shr_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_stat_get_backend_wait_event() { return &GenericExec<TPgDirectFunc<&pg_stat_get_backend_wait_event>, true, false, TArgs_pg_stat_get_backend_wait_event_Policy>; }
-struct TArgs_pg_stat_get_backend_wait_event_type_Policy {
+TExecFunc arrow_int8shr() { return TGenericExec<TPgDirectFunc<&int8shr>, true, true, TArgs_int8shr_Policy>({}); }
+struct TArgs_int8smaller_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+};
+TExecFunc arrow_int8smaller() { return TGenericExec<TPgDirectFunc<&int8smaller>, true, true, TArgs_int8smaller_Policy>({}); }
+struct TArgs_int8um_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_stat_get_backend_wait_event_type() { return &GenericExec<TPgDirectFunc<&pg_stat_get_backend_wait_event_type>, true, false, TArgs_pg_stat_get_backend_wait_event_type_Policy>; }
-struct TArgs_pg_stat_get_backend_xact_start_Policy {
+TExecFunc arrow_int8um() { return TGenericExec<TPgDirectFunc<&int8um>, true, true, TArgs_int8um_Policy>({}); }
+struct TArgs_int8up_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_stat_get_backend_xact_start() { return &GenericExec<TPgDirectFunc<&pg_stat_get_backend_xact_start>, true, true, TArgs_pg_stat_get_backend_xact_start_Policy>; }
-struct TArgs_pg_stat_get_bgwriter_buf_written_checkpoints_Policy {
+TExecFunc arrow_int8up() { return TGenericExec<TPgDirectFunc<&int8up>, true, true, TArgs_int8up_Policy>({}); }
+struct TArgs_int8xor_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_stat_get_bgwriter_buf_written_checkpoints() { return &GenericExec<TPgDirectFunc<&pg_stat_get_bgwriter_buf_written_checkpoints>, true, true, TArgs_pg_stat_get_bgwriter_buf_written_checkpoints_Policy>; }
-struct TArgs_pg_stat_get_bgwriter_buf_written_clean_Policy {
+TExecFunc arrow_int8xor() { return TGenericExec<TPgDirectFunc<&int8xor>, true, true, TArgs_int8xor_Policy>({}); }
+struct TArgs_interval_time_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_stat_get_bgwriter_buf_written_clean() { return &GenericExec<TPgDirectFunc<&pg_stat_get_bgwriter_buf_written_clean>, true, true, TArgs_pg_stat_get_bgwriter_buf_written_clean_Policy>; }
-struct TArgs_pg_stat_get_bgwriter_maxwritten_clean_Policy {
+TExecFunc arrow_interval_time() { return TGenericExec<TPgDirectFunc<&interval_time>, true, true, TArgs_interval_time_Policy>({}); }
+struct TArgs_json_string_to_tsvector_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_stat_get_bgwriter_maxwritten_clean() { return &GenericExec<TPgDirectFunc<&pg_stat_get_bgwriter_maxwritten_clean>, true, true, TArgs_pg_stat_get_bgwriter_maxwritten_clean_Policy>; }
-struct TArgs_pg_stat_get_bgwriter_requested_checkpoints_Policy {
+TExecFunc arrow_json_string_to_tsvector() { return TGenericExec<TPgDirectFunc<&json_string_to_tsvector>, true, false, TArgs_json_string_to_tsvector_Policy>({}); }
+struct TArgs_json_string_to_tsvector_byid_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_pg_stat_get_bgwriter_requested_checkpoints() { return &GenericExec<TPgDirectFunc<&pg_stat_get_bgwriter_requested_checkpoints>, true, true, TArgs_pg_stat_get_bgwriter_requested_checkpoints_Policy>; }
-struct TArgs_pg_stat_get_bgwriter_stat_reset_time_Policy {
+TExecFunc arrow_json_string_to_tsvector_byid() { return TGenericExec<TPgDirectFunc<&json_string_to_tsvector_byid>, true, false, TArgs_json_string_to_tsvector_byid_Policy>({}); }
+struct TArgs_json_to_tsvector_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_stat_get_bgwriter_stat_reset_time() { return &GenericExec<TPgDirectFunc<&pg_stat_get_bgwriter_stat_reset_time>, true, true, TArgs_pg_stat_get_bgwriter_stat_reset_time_Policy>; }
-struct TArgs_pg_stat_get_bgwriter_timed_checkpoints_Policy {
+TExecFunc arrow_json_to_tsvector() { return TGenericExec<TPgDirectFunc<&json_to_tsvector>, true, false, TArgs_json_to_tsvector_Policy>({}); }
+struct TArgs_json_to_tsvector_byid_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
 };
-TExecFunc arrow_pg_stat_get_bgwriter_timed_checkpoints() { return &GenericExec<TPgDirectFunc<&pg_stat_get_bgwriter_timed_checkpoints>, true, true, TArgs_pg_stat_get_bgwriter_timed_checkpoints_Policy>; }
-struct TArgs_pg_stat_get_blocks_fetched_Policy {
+TExecFunc arrow_json_to_tsvector_byid() { return TGenericExec<TPgDirectFunc<&json_to_tsvector_byid>, true, false, TArgs_json_to_tsvector_byid_Policy>({}); }
+struct TArgs_jsonb_cmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_stat_get_blocks_fetched() { return &GenericExec<TPgDirectFunc<&pg_stat_get_blocks_fetched>, true, true, TArgs_pg_stat_get_blocks_fetched_Policy>; }
-struct TArgs_pg_stat_get_blocks_hit_Policy {
+TExecFunc arrow_jsonb_cmp() { return TGenericExec<TPgDirectFunc<&jsonb_cmp>, true, true, TArgs_jsonb_cmp_Policy>({}); }
+struct TArgs_jsonb_contained_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_stat_get_blocks_hit() { return &GenericExec<TPgDirectFunc<&pg_stat_get_blocks_hit>, true, true, TArgs_pg_stat_get_blocks_hit_Policy>; }
-struct TArgs_pg_stat_get_buf_alloc_Policy {
+TExecFunc arrow_jsonb_contained() { return TGenericExec<TPgDirectFunc<&jsonb_contained>, true, true, TArgs_jsonb_contained_Policy>({}); }
+struct TArgs_jsonb_contains_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_stat_get_buf_alloc() { return &GenericExec<TPgDirectFunc<&pg_stat_get_buf_alloc>, true, true, TArgs_pg_stat_get_buf_alloc_Policy>; }
-struct TArgs_pg_stat_get_buf_fsync_backend_Policy {
+TExecFunc arrow_jsonb_contains() { return TGenericExec<TPgDirectFunc<&jsonb_contains>, true, true, TArgs_jsonb_contains_Policy>({}); }
+struct TArgs_jsonb_eq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_stat_get_buf_fsync_backend() { return &GenericExec<TPgDirectFunc<&pg_stat_get_buf_fsync_backend>, true, true, TArgs_pg_stat_get_buf_fsync_backend_Policy>; }
-struct TArgs_pg_stat_get_buf_written_backend_Policy {
+TExecFunc arrow_jsonb_eq() { return TGenericExec<TPgDirectFunc<&jsonb_eq>, true, true, TArgs_jsonb_eq_Policy>({}); }
+struct TArgs_jsonb_exists_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_stat_get_buf_written_backend() { return &GenericExec<TPgDirectFunc<&pg_stat_get_buf_written_backend>, true, true, TArgs_pg_stat_get_buf_written_backend_Policy>; }
-struct TArgs_pg_stat_get_checkpoint_sync_time_Policy {
+TExecFunc arrow_jsonb_exists() { return TGenericExec<TPgDirectFunc<&jsonb_exists>, true, true, TArgs_jsonb_exists_Policy>({}); }
+struct TArgs_jsonb_exists_all_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_stat_get_checkpoint_sync_time() { return &GenericExec<TPgDirectFunc<&pg_stat_get_checkpoint_sync_time>, true, true, TArgs_pg_stat_get_checkpoint_sync_time_Policy>; }
-struct TArgs_pg_stat_get_checkpoint_write_time_Policy {
+TExecFunc arrow_jsonb_exists_all() { return TGenericExec<TPgDirectFunc<&jsonb_exists_all>, true, true, TArgs_jsonb_exists_all_Policy>({}); }
+struct TArgs_jsonb_exists_any_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_stat_get_checkpoint_write_time() { return &GenericExec<TPgDirectFunc<&pg_stat_get_checkpoint_write_time>, true, true, TArgs_pg_stat_get_checkpoint_write_time_Policy>; }
-struct TArgs_pg_stat_get_db_active_time_Policy {
+TExecFunc arrow_jsonb_exists_any() { return TGenericExec<TPgDirectFunc<&jsonb_exists_any>, true, true, TArgs_jsonb_exists_any_Policy>({}); }
+struct TArgs_jsonb_ge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_stat_get_db_active_time() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_active_time>, true, true, TArgs_pg_stat_get_db_active_time_Policy>; }
-struct TArgs_pg_stat_get_db_blk_read_time_Policy {
+TExecFunc arrow_jsonb_ge() { return TGenericExec<TPgDirectFunc<&jsonb_ge>, true, true, TArgs_jsonb_ge_Policy>({}); }
+struct TArgs_jsonb_gt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_stat_get_db_blk_read_time() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_blk_read_time>, true, true, TArgs_pg_stat_get_db_blk_read_time_Policy>; }
-struct TArgs_pg_stat_get_db_blk_write_time_Policy {
+TExecFunc arrow_jsonb_gt() { return TGenericExec<TPgDirectFunc<&jsonb_gt>, true, true, TArgs_jsonb_gt_Policy>({}); }
+struct TArgs_jsonb_hash_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_stat_get_db_blk_write_time() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_blk_write_time>, true, true, TArgs_pg_stat_get_db_blk_write_time_Policy>; }
-struct TArgs_pg_stat_get_db_blocks_fetched_Policy {
+TExecFunc arrow_jsonb_hash() { return TGenericExec<TPgDirectFunc<&jsonb_hash>, true, true, TArgs_jsonb_hash_Policy>({}); }
+struct TArgs_jsonb_hash_extended_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_pg_stat_get_db_blocks_fetched() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_blocks_fetched>, true, true, TArgs_pg_stat_get_db_blocks_fetched_Policy>; }
-struct TArgs_pg_stat_get_db_blocks_hit_Policy {
+TExecFunc arrow_jsonb_hash_extended() { return TGenericExec<TPgDirectFunc<&jsonb_hash_extended>, true, true, TArgs_jsonb_hash_extended_Policy>({}); }
+struct TArgs_jsonb_le_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_stat_get_db_blocks_hit() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_blocks_hit>, true, true, TArgs_pg_stat_get_db_blocks_hit_Policy>; }
-struct TArgs_pg_stat_get_db_checksum_failures_Policy {
+TExecFunc arrow_jsonb_le() { return TGenericExec<TPgDirectFunc<&jsonb_le>, true, true, TArgs_jsonb_le_Policy>({}); }
+struct TArgs_jsonb_lt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_stat_get_db_checksum_failures() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_checksum_failures>, true, true, TArgs_pg_stat_get_db_checksum_failures_Policy>; }
-struct TArgs_pg_stat_get_db_checksum_last_failure_Policy {
+TExecFunc arrow_jsonb_lt() { return TGenericExec<TPgDirectFunc<&jsonb_lt>, true, true, TArgs_jsonb_lt_Policy>({}); }
+struct TArgs_jsonb_ne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_stat_get_db_checksum_last_failure() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_checksum_last_failure>, true, true, TArgs_pg_stat_get_db_checksum_last_failure_Policy>; }
-struct TArgs_pg_stat_get_db_conflict_all_Policy {
+TExecFunc arrow_jsonb_ne() { return TGenericExec<TPgDirectFunc<&jsonb_ne>, true, true, TArgs_jsonb_ne_Policy>({}); }
+struct TArgs_jsonb_path_exists_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,true};
 };
-TExecFunc arrow_pg_stat_get_db_conflict_all() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_conflict_all>, true, true, TArgs_pg_stat_get_db_conflict_all_Policy>; }
-struct TArgs_pg_stat_get_db_conflict_bufferpin_Policy {
+TExecFunc arrow_jsonb_path_exists() { return TGenericExec<TPgDirectFunc<&jsonb_path_exists>, true, true, TArgs_jsonb_path_exists_Policy>({}); }
+struct TArgs_jsonb_path_exists_opr_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_stat_get_db_conflict_bufferpin() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_conflict_bufferpin>, true, true, TArgs_pg_stat_get_db_conflict_bufferpin_Policy>; }
-struct TArgs_pg_stat_get_db_conflict_lock_Policy {
+TExecFunc arrow_jsonb_path_exists_opr() { return TGenericExec<TPgDirectFunc<&jsonb_path_exists_opr>, true, true, TArgs_jsonb_path_exists_opr_Policy>({}); }
+struct TArgs_jsonb_path_exists_tz_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,true};
 };
-TExecFunc arrow_pg_stat_get_db_conflict_lock() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_conflict_lock>, true, true, TArgs_pg_stat_get_db_conflict_lock_Policy>; }
-struct TArgs_pg_stat_get_db_conflict_snapshot_Policy {
+TExecFunc arrow_jsonb_path_exists_tz() { return TGenericExec<TPgDirectFunc<&jsonb_path_exists_tz>, true, true, TArgs_jsonb_path_exists_tz_Policy>({}); }
+struct TArgs_jsonb_path_match_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,true};
 };
-TExecFunc arrow_pg_stat_get_db_conflict_snapshot() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_conflict_snapshot>, true, true, TArgs_pg_stat_get_db_conflict_snapshot_Policy>; }
-struct TArgs_pg_stat_get_db_conflict_startup_deadlock_Policy {
+TExecFunc arrow_jsonb_path_match() { return TGenericExec<TPgDirectFunc<&jsonb_path_match>, true, true, TArgs_jsonb_path_match_Policy>({}); }
+struct TArgs_jsonb_path_match_opr_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_stat_get_db_conflict_startup_deadlock() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_conflict_startup_deadlock>, true, true, TArgs_pg_stat_get_db_conflict_startup_deadlock_Policy>; }
-struct TArgs_pg_stat_get_db_conflict_tablespace_Policy {
+TExecFunc arrow_jsonb_path_match_opr() { return TGenericExec<TPgDirectFunc<&jsonb_path_match_opr>, true, true, TArgs_jsonb_path_match_opr_Policy>({}); }
+struct TArgs_jsonb_path_match_tz_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,true};
 };
-TExecFunc arrow_pg_stat_get_db_conflict_tablespace() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_conflict_tablespace>, true, true, TArgs_pg_stat_get_db_conflict_tablespace_Policy>; }
-struct TArgs_pg_stat_get_db_deadlocks_Policy {
+TExecFunc arrow_jsonb_path_match_tz() { return TGenericExec<TPgDirectFunc<&jsonb_path_match_tz>, true, true, TArgs_jsonb_path_match_tz_Policy>({}); }
+struct TArgs_jsonb_path_query_array_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,true};
 };
-TExecFunc arrow_pg_stat_get_db_deadlocks() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_deadlocks>, true, true, TArgs_pg_stat_get_db_deadlocks_Policy>; }
-struct TArgs_pg_stat_get_db_idle_in_transaction_time_Policy {
+TExecFunc arrow_jsonb_path_query_array() { return TGenericExec<TPgDirectFunc<&jsonb_path_query_array>, true, false, TArgs_jsonb_path_query_array_Policy>({}); }
+struct TArgs_jsonb_path_query_array_tz_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,true};
 };
-TExecFunc arrow_pg_stat_get_db_idle_in_transaction_time() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_idle_in_transaction_time>, true, true, TArgs_pg_stat_get_db_idle_in_transaction_time_Policy>; }
-struct TArgs_pg_stat_get_db_numbackends_Policy {
+TExecFunc arrow_jsonb_path_query_array_tz() { return TGenericExec<TPgDirectFunc<&jsonb_path_query_array_tz>, true, false, TArgs_jsonb_path_query_array_tz_Policy>({}); }
+struct TArgs_jsonb_path_query_first_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,true};
 };
-TExecFunc arrow_pg_stat_get_db_numbackends() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_numbackends>, true, true, TArgs_pg_stat_get_db_numbackends_Policy>; }
-struct TArgs_pg_stat_get_db_session_time_Policy {
+TExecFunc arrow_jsonb_path_query_first() { return TGenericExec<TPgDirectFunc<&jsonb_path_query_first>, true, false, TArgs_jsonb_path_query_first_Policy>({}); }
+struct TArgs_jsonb_path_query_first_tz_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,true};
 };
-TExecFunc arrow_pg_stat_get_db_session_time() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_session_time>, true, true, TArgs_pg_stat_get_db_session_time_Policy>; }
-struct TArgs_pg_stat_get_db_sessions_Policy {
+TExecFunc arrow_jsonb_path_query_first_tz() { return TGenericExec<TPgDirectFunc<&jsonb_path_query_first_tz>, true, false, TArgs_jsonb_path_query_first_tz_Policy>({}); }
+struct TArgs_jsonb_string_to_tsvector_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_stat_get_db_sessions() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_sessions>, true, true, TArgs_pg_stat_get_db_sessions_Policy>; }
-struct TArgs_pg_stat_get_db_sessions_abandoned_Policy {
+TExecFunc arrow_jsonb_string_to_tsvector() { return TGenericExec<TPgDirectFunc<&jsonb_string_to_tsvector>, true, false, TArgs_jsonb_string_to_tsvector_Policy>({}); }
+struct TArgs_jsonb_string_to_tsvector_byid_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_pg_stat_get_db_sessions_abandoned() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_sessions_abandoned>, true, true, TArgs_pg_stat_get_db_sessions_abandoned_Policy>; }
-struct TArgs_pg_stat_get_db_sessions_fatal_Policy {
+TExecFunc arrow_jsonb_string_to_tsvector_byid() { return TGenericExec<TPgDirectFunc<&jsonb_string_to_tsvector_byid>, true, false, TArgs_jsonb_string_to_tsvector_byid_Policy>({}); }
+struct TArgs_jsonb_to_tsvector_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_stat_get_db_sessions_fatal() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_sessions_fatal>, true, true, TArgs_pg_stat_get_db_sessions_fatal_Policy>; }
-struct TArgs_pg_stat_get_db_sessions_killed_Policy {
+TExecFunc arrow_jsonb_to_tsvector() { return TGenericExec<TPgDirectFunc<&jsonb_to_tsvector>, true, false, TArgs_jsonb_to_tsvector_Policy>({}); }
+struct TArgs_jsonb_to_tsvector_byid_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
 };
-TExecFunc arrow_pg_stat_get_db_sessions_killed() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_sessions_killed>, true, true, TArgs_pg_stat_get_db_sessions_killed_Policy>; }
-struct TArgs_pg_stat_get_db_stat_reset_time_Policy {
+TExecFunc arrow_jsonb_to_tsvector_byid() { return TGenericExec<TPgDirectFunc<&jsonb_to_tsvector_byid>, true, false, TArgs_jsonb_to_tsvector_byid_Policy>({}); }
+struct TArgs_make_date_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_pg_stat_get_db_stat_reset_time() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_stat_reset_time>, true, true, TArgs_pg_stat_get_db_stat_reset_time_Policy>; }
-struct TArgs_pg_stat_get_db_temp_bytes_Policy {
+TExecFunc arrow_make_date() { return TGenericExec<TPgDirectFunc<&make_date>, true, true, TArgs_make_date_Policy>({}); }
+struct TArgs_make_time_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_pg_stat_get_db_temp_bytes() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_temp_bytes>, true, true, TArgs_pg_stat_get_db_temp_bytes_Policy>; }
-struct TArgs_pg_stat_get_db_temp_files_Policy {
+TExecFunc arrow_make_time() { return TGenericExec<TPgDirectFunc<&make_time>, true, true, TArgs_make_time_Policy>({}); }
+struct TArgs_makeaclitem_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,false,true};
 };
-TExecFunc arrow_pg_stat_get_db_temp_files() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_temp_files>, true, true, TArgs_pg_stat_get_db_temp_files_Policy>; }
-struct TArgs_pg_stat_get_db_tuples_deleted_Policy {
+TExecFunc arrow_makeaclitem() { return TGenericExec<TPgDirectFunc<&makeaclitem>, true, false, TArgs_makeaclitem_Policy>({}); }
+struct TArgs_multirange_gist_compress_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_stat_get_db_tuples_deleted() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_tuples_deleted>, true, true, TArgs_pg_stat_get_db_tuples_deleted_Policy>; }
-struct TArgs_pg_stat_get_db_tuples_fetched_Policy {
+TExecFunc arrow_multirange_gist_compress() { return TGenericExec<TPgDirectFunc<&multirange_gist_compress>, true, true, TArgs_multirange_gist_compress_Policy>({}); }
+struct TArgs_multirange_gist_consistent_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,false,true,true,true};
 };
-TExecFunc arrow_pg_stat_get_db_tuples_fetched() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_tuples_fetched>, true, true, TArgs_pg_stat_get_db_tuples_fetched_Policy>; }
-struct TArgs_pg_stat_get_db_tuples_inserted_Policy {
+TExecFunc arrow_multirange_gist_consistent() { return TGenericExec<TPgDirectFunc<&multirange_gist_consistent>, true, true, TArgs_multirange_gist_consistent_Policy>({}); }
+struct TArgs_multirange_typanalyze_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_stat_get_db_tuples_inserted() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_tuples_inserted>, true, true, TArgs_pg_stat_get_db_tuples_inserted_Policy>; }
-struct TArgs_pg_stat_get_db_tuples_returned_Policy {
+TExecFunc arrow_multirange_typanalyze() { return TGenericExec<TPgDirectFunc<&multirange_typanalyze>, true, true, TArgs_multirange_typanalyze_Policy>({}); }
+struct TArgs_name_text_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_stat_get_db_tuples_returned() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_tuples_returned>, true, true, TArgs_pg_stat_get_db_tuples_returned_Policy>; }
-struct TArgs_pg_stat_get_db_tuples_updated_Policy {
+TExecFunc arrow_name_text() { return TGenericExec<TPgDirectFunc<&name_text>, true, false, TArgs_name_text_Policy>({}); }
+struct TArgs_nameeqtext_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_stat_get_db_tuples_updated() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_tuples_updated>, true, true, TArgs_pg_stat_get_db_tuples_updated_Policy>; }
-struct TArgs_pg_stat_get_db_xact_commit_Policy {
+TExecFunc arrow_nameeqtext() { return TGenericExec<TPgDirectFunc<&nameeqtext>, true, true, TArgs_nameeqtext_Policy>({}); }
+struct TArgs_namegetext_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_stat_get_db_xact_commit() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_xact_commit>, true, true, TArgs_pg_stat_get_db_xact_commit_Policy>; }
-struct TArgs_pg_stat_get_db_xact_rollback_Policy {
+TExecFunc arrow_namegetext() { return TGenericExec<TPgDirectFunc<&namegetext>, true, true, TArgs_namegetext_Policy>({}); }
+struct TArgs_namegttext_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_stat_get_db_xact_rollback() { return &GenericExec<TPgDirectFunc<&pg_stat_get_db_xact_rollback>, true, true, TArgs_pg_stat_get_db_xact_rollback_Policy>; }
-struct TArgs_pg_stat_get_dead_tuples_Policy {
+TExecFunc arrow_namegttext() { return TGenericExec<TPgDirectFunc<&namegttext>, true, true, TArgs_namegttext_Policy>({}); }
+struct TArgs_nameletext_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_stat_get_dead_tuples() { return &GenericExec<TPgDirectFunc<&pg_stat_get_dead_tuples>, true, true, TArgs_pg_stat_get_dead_tuples_Policy>; }
-struct TArgs_pg_stat_get_function_calls_Policy {
+TExecFunc arrow_nameletext() { return TGenericExec<TPgDirectFunc<&nameletext>, true, true, TArgs_nameletext_Policy>({}); }
+struct TArgs_namelttext_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_stat_get_function_calls() { return &GenericExec<TPgDirectFunc<&pg_stat_get_function_calls>, true, true, TArgs_pg_stat_get_function_calls_Policy>; }
-struct TArgs_pg_stat_get_function_self_time_Policy {
+TExecFunc arrow_namelttext() { return TGenericExec<TPgDirectFunc<&namelttext>, true, true, TArgs_namelttext_Policy>({}); }
+struct TArgs_namenetext_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_stat_get_function_self_time() { return &GenericExec<TPgDirectFunc<&pg_stat_get_function_self_time>, true, true, TArgs_pg_stat_get_function_self_time_Policy>; }
-struct TArgs_pg_stat_get_function_total_time_Policy {
+TExecFunc arrow_namenetext() { return TGenericExec<TPgDirectFunc<&namenetext>, true, true, TArgs_namenetext_Policy>({}); }
+struct TArgs_oidtoi8_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_stat_get_function_total_time() { return &GenericExec<TPgDirectFunc<&pg_stat_get_function_total_time>, true, true, TArgs_pg_stat_get_function_total_time_Policy>; }
-struct TArgs_pg_stat_get_ins_since_vacuum_Policy {
+TExecFunc arrow_oidtoi8() { return TGenericExec<TPgDirectFunc<&oidtoi8>, true, true, TArgs_oidtoi8_Policy>({}); }
+struct TArgs_overlaps_time_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_pg_stat_get_ins_since_vacuum() { return &GenericExec<TPgDirectFunc<&pg_stat_get_ins_since_vacuum>, true, true, TArgs_pg_stat_get_ins_since_vacuum_Policy>; }
-struct TArgs_pg_stat_get_last_analyze_time_Policy {
+TExecFunc arrow_overlaps_time() { return TGenericExec<TPgDirectFunc<&overlaps_time>, false, true, TArgs_overlaps_time_Policy>({}); }
+struct TArgs_overlaps_timetz_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,false};
 };
-TExecFunc arrow_pg_stat_get_last_analyze_time() { return &GenericExec<TPgDirectFunc<&pg_stat_get_last_analyze_time>, true, true, TArgs_pg_stat_get_last_analyze_time_Policy>; }
-struct TArgs_pg_stat_get_last_autoanalyze_time_Policy {
+TExecFunc arrow_overlaps_timetz() { return TGenericExec<TPgDirectFunc<&overlaps_timetz>, false, true, TArgs_overlaps_timetz_Policy>({}); }
+struct TArgs_pg_advisory_lock_int4_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_stat_get_last_autoanalyze_time() { return &GenericExec<TPgDirectFunc<&pg_stat_get_last_autoanalyze_time>, true, true, TArgs_pg_stat_get_last_autoanalyze_time_Policy>; }
-struct TArgs_pg_stat_get_last_autovacuum_time_Policy {
+TExecFunc arrow_pg_advisory_lock_int4() { return TGenericExec<TPgDirectFunc<&pg_advisory_lock_int4>, true, true, TArgs_pg_advisory_lock_int4_Policy>({}); }
+struct TArgs_pg_advisory_lock_int8_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_stat_get_last_autovacuum_time() { return &GenericExec<TPgDirectFunc<&pg_stat_get_last_autovacuum_time>, true, true, TArgs_pg_stat_get_last_autovacuum_time_Policy>; }
-struct TArgs_pg_stat_get_last_vacuum_time_Policy {
+TExecFunc arrow_pg_advisory_lock_int8() { return TGenericExec<TPgDirectFunc<&pg_advisory_lock_int8>, true, true, TArgs_pg_advisory_lock_int8_Policy>({}); }
+struct TArgs_pg_advisory_lock_shared_int4_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_stat_get_last_vacuum_time() { return &GenericExec<TPgDirectFunc<&pg_stat_get_last_vacuum_time>, true, true, TArgs_pg_stat_get_last_vacuum_time_Policy>; }
-struct TArgs_pg_stat_get_live_tuples_Policy {
+TExecFunc arrow_pg_advisory_lock_shared_int4() { return TGenericExec<TPgDirectFunc<&pg_advisory_lock_shared_int4>, true, true, TArgs_pg_advisory_lock_shared_int4_Policy>({}); }
+struct TArgs_pg_advisory_lock_shared_int8_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_stat_get_live_tuples() { return &GenericExec<TPgDirectFunc<&pg_stat_get_live_tuples>, true, true, TArgs_pg_stat_get_live_tuples_Policy>; }
-struct TArgs_pg_stat_get_mod_since_analyze_Policy {
+TExecFunc arrow_pg_advisory_lock_shared_int8() { return TGenericExec<TPgDirectFunc<&pg_advisory_lock_shared_int8>, true, true, TArgs_pg_advisory_lock_shared_int8_Policy>({}); }
+struct TArgs_pg_advisory_unlock_all_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
+};
+TExecFunc arrow_pg_advisory_unlock_all() { return TGenericExec<TPgDirectFunc<&pg_advisory_unlock_all>, true, true, TArgs_pg_advisory_unlock_all_Policy>({}); }
+struct TArgs_pg_advisory_unlock_int4_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_stat_get_mod_since_analyze() { return &GenericExec<TPgDirectFunc<&pg_stat_get_mod_since_analyze>, true, true, TArgs_pg_stat_get_mod_since_analyze_Policy>; }
-struct TArgs_pg_stat_get_numscans_Policy {
+TExecFunc arrow_pg_advisory_unlock_int4() { return TGenericExec<TPgDirectFunc<&pg_advisory_unlock_int4>, true, true, TArgs_pg_advisory_unlock_int4_Policy>({}); }
+struct TArgs_pg_advisory_unlock_int8_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_stat_get_numscans() { return &GenericExec<TPgDirectFunc<&pg_stat_get_numscans>, true, true, TArgs_pg_stat_get_numscans_Policy>; }
-struct TArgs_pg_stat_get_snapshot_timestamp_Policy {
+TExecFunc arrow_pg_advisory_unlock_int8() { return TGenericExec<TPgDirectFunc<&pg_advisory_unlock_int8>, true, true, TArgs_pg_advisory_unlock_int8_Policy>({}); }
+struct TArgs_pg_advisory_unlock_shared_int4_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_stat_get_snapshot_timestamp() { return &GenericExec<TPgDirectFunc<&pg_stat_get_snapshot_timestamp>, true, true, TArgs_pg_stat_get_snapshot_timestamp_Policy>; }
-struct TArgs_pg_stat_get_tuples_deleted_Policy {
+TExecFunc arrow_pg_advisory_unlock_shared_int4() { return TGenericExec<TPgDirectFunc<&pg_advisory_unlock_shared_int4>, true, true, TArgs_pg_advisory_unlock_shared_int4_Policy>({}); }
+struct TArgs_pg_advisory_unlock_shared_int8_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_stat_get_tuples_deleted() { return &GenericExec<TPgDirectFunc<&pg_stat_get_tuples_deleted>, true, true, TArgs_pg_stat_get_tuples_deleted_Policy>; }
-struct TArgs_pg_stat_get_tuples_fetched_Policy {
+TExecFunc arrow_pg_advisory_unlock_shared_int8() { return TGenericExec<TPgDirectFunc<&pg_advisory_unlock_shared_int8>, true, true, TArgs_pg_advisory_unlock_shared_int8_Policy>({}); }
+struct TArgs_pg_advisory_xact_lock_int4_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+};
+TExecFunc arrow_pg_advisory_xact_lock_int4() { return TGenericExec<TPgDirectFunc<&pg_advisory_xact_lock_int4>, true, true, TArgs_pg_advisory_xact_lock_int4_Policy>({}); }
+struct TArgs_pg_advisory_xact_lock_int8_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_stat_get_tuples_fetched() { return &GenericExec<TPgDirectFunc<&pg_stat_get_tuples_fetched>, true, true, TArgs_pg_stat_get_tuples_fetched_Policy>; }
-struct TArgs_pg_stat_get_tuples_hot_updated_Policy {
+TExecFunc arrow_pg_advisory_xact_lock_int8() { return TGenericExec<TPgDirectFunc<&pg_advisory_xact_lock_int8>, true, true, TArgs_pg_advisory_xact_lock_int8_Policy>({}); }
+struct TArgs_pg_advisory_xact_lock_shared_int4_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+};
+TExecFunc arrow_pg_advisory_xact_lock_shared_int4() { return TGenericExec<TPgDirectFunc<&pg_advisory_xact_lock_shared_int4>, true, true, TArgs_pg_advisory_xact_lock_shared_int4_Policy>({}); }
+struct TArgs_pg_advisory_xact_lock_shared_int8_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_stat_get_tuples_hot_updated() { return &GenericExec<TPgDirectFunc<&pg_stat_get_tuples_hot_updated>, true, true, TArgs_pg_stat_get_tuples_hot_updated_Policy>; }
-struct TArgs_pg_stat_get_tuples_inserted_Policy {
+TExecFunc arrow_pg_advisory_xact_lock_shared_int8() { return TGenericExec<TPgDirectFunc<&pg_advisory_xact_lock_shared_int8>, true, true, TArgs_pg_advisory_xact_lock_shared_int8_Policy>({}); }
+struct TArgs_pg_blocking_pids_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_stat_get_tuples_inserted() { return &GenericExec<TPgDirectFunc<&pg_stat_get_tuples_inserted>, true, true, TArgs_pg_stat_get_tuples_inserted_Policy>; }
-struct TArgs_pg_stat_get_tuples_returned_Policy {
+TExecFunc arrow_pg_blocking_pids() { return TGenericExec<TPgDirectFunc<&pg_blocking_pids>, true, false, TArgs_pg_blocking_pids_Policy>({}); }
+struct TArgs_pg_collation_actual_version_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_stat_get_tuples_returned() { return &GenericExec<TPgDirectFunc<&pg_stat_get_tuples_returned>, true, true, TArgs_pg_stat_get_tuples_returned_Policy>; }
-struct TArgs_pg_stat_get_tuples_updated_Policy {
+TExecFunc arrow_pg_collation_actual_version() { return TGenericExec<TPgDirectFunc<&pg_collation_actual_version>, true, false, TArgs_pg_collation_actual_version_Policy>({}); }
+struct TArgs_pg_column_compression_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_stat_get_tuples_updated() { return &GenericExec<TPgDirectFunc<&pg_stat_get_tuples_updated>, true, true, TArgs_pg_stat_get_tuples_updated_Policy>; }
-struct TArgs_pg_stat_get_vacuum_count_Policy {
+TExecFunc arrow_pg_column_compression() { return TGenericExec<TPgDirectFunc<&pg_column_compression>, true, false, TArgs_pg_column_compression_Policy>({}); }
+struct TArgs_pg_column_size_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_stat_get_vacuum_count() { return &GenericExec<TPgDirectFunc<&pg_stat_get_vacuum_count>, true, true, TArgs_pg_stat_get_vacuum_count_Policy>; }
-struct TArgs_pg_stat_get_wal_Policy {
+TExecFunc arrow_pg_column_size() { return TGenericExec<TPgDirectFunc<&pg_column_size>, true, true, TArgs_pg_column_size_Policy>({}); }
+struct TArgs_pg_dependencies_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_stat_get_wal() { return &GenericExec<TPgDirectFunc<&pg_stat_get_wal>, false, false, TArgs_pg_stat_get_wal_Policy>; }
-struct TArgs_pg_stat_get_xact_blocks_fetched_Policy {
+TExecFunc arrow_pg_dependencies_in() { return TGenericExec<TPgDirectFunc<&pg_dependencies_in>, true, false, TArgs_pg_dependencies_in_Policy>({}); }
+struct TArgs_pg_dependencies_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_stat_get_xact_blocks_fetched() { return &GenericExec<TPgDirectFunc<&pg_stat_get_xact_blocks_fetched>, true, true, TArgs_pg_stat_get_xact_blocks_fetched_Policy>; }
-struct TArgs_pg_stat_get_xact_blocks_hit_Policy {
+TExecFunc arrow_pg_dependencies_out() { return TGenericExec<TPgDirectFunc<&pg_dependencies_out>, true, false, TArgs_pg_dependencies_out_Policy>({}); }
+struct TArgs_pg_dependencies_recv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_stat_get_xact_blocks_hit() { return &GenericExec<TPgDirectFunc<&pg_stat_get_xact_blocks_hit>, true, true, TArgs_pg_stat_get_xact_blocks_hit_Policy>; }
-struct TArgs_pg_stat_get_xact_function_calls_Policy {
+TExecFunc arrow_pg_dependencies_recv() { return TGenericExec<TPgDirectFunc<&pg_dependencies_recv>, true, false, TArgs_pg_dependencies_recv_Policy>({}); }
+struct TArgs_pg_dependencies_send_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_stat_get_xact_function_calls() { return &GenericExec<TPgDirectFunc<&pg_stat_get_xact_function_calls>, true, true, TArgs_pg_stat_get_xact_function_calls_Policy>; }
-struct TArgs_pg_stat_get_xact_function_self_time_Policy {
+TExecFunc arrow_pg_dependencies_send() { return TGenericExec<TPgDirectFunc<&pg_dependencies_send>, true, false, TArgs_pg_dependencies_send_Policy>({}); }
+struct TArgs_pg_event_trigger_table_rewrite_oid_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_pg_stat_get_xact_function_self_time() { return &GenericExec<TPgDirectFunc<&pg_stat_get_xact_function_self_time>, true, true, TArgs_pg_stat_get_xact_function_self_time_Policy>; }
-struct TArgs_pg_stat_get_xact_function_total_time_Policy {
+TExecFunc arrow_pg_event_trigger_table_rewrite_oid() { return TGenericExec<TPgDirectFunc<&pg_event_trigger_table_rewrite_oid>, true, true, TArgs_pg_event_trigger_table_rewrite_oid_Policy>({}); }
+struct TArgs_pg_event_trigger_table_rewrite_reason_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_pg_stat_get_xact_function_total_time() { return &GenericExec<TPgDirectFunc<&pg_stat_get_xact_function_total_time>, true, true, TArgs_pg_stat_get_xact_function_total_time_Policy>; }
-struct TArgs_pg_stat_get_xact_numscans_Policy {
+TExecFunc arrow_pg_event_trigger_table_rewrite_reason() { return TGenericExec<TPgDirectFunc<&pg_event_trigger_table_rewrite_reason>, true, true, TArgs_pg_event_trigger_table_rewrite_reason_Policy>({}); }
+struct TArgs_pg_has_role_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_pg_stat_get_xact_numscans() { return &GenericExec<TPgDirectFunc<&pg_stat_get_xact_numscans>, true, true, TArgs_pg_stat_get_xact_numscans_Policy>; }
-struct TArgs_pg_stat_get_xact_tuples_deleted_Policy {
+TExecFunc arrow_pg_has_role_id() { return TGenericExec<TPgDirectFunc<&pg_has_role_id>, true, true, TArgs_pg_has_role_id_Policy>({}); }
+struct TArgs_pg_has_role_id_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
 };
-TExecFunc arrow_pg_stat_get_xact_tuples_deleted() { return &GenericExec<TPgDirectFunc<&pg_stat_get_xact_tuples_deleted>, true, true, TArgs_pg_stat_get_xact_tuples_deleted_Policy>; }
-struct TArgs_pg_stat_get_xact_tuples_fetched_Policy {
+TExecFunc arrow_pg_has_role_id_id() { return TGenericExec<TPgDirectFunc<&pg_has_role_id_id>, true, true, TArgs_pg_has_role_id_id_Policy>({}); }
+struct TArgs_pg_has_role_id_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
 };
-TExecFunc arrow_pg_stat_get_xact_tuples_fetched() { return &GenericExec<TPgDirectFunc<&pg_stat_get_xact_tuples_fetched>, true, true, TArgs_pg_stat_get_xact_tuples_fetched_Policy>; }
-struct TArgs_pg_stat_get_xact_tuples_hot_updated_Policy {
+TExecFunc arrow_pg_has_role_id_name() { return TGenericExec<TPgDirectFunc<&pg_has_role_id_name>, true, true, TArgs_pg_has_role_id_name_Policy>({}); }
+struct TArgs_pg_has_role_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_stat_get_xact_tuples_hot_updated() { return &GenericExec<TPgDirectFunc<&pg_stat_get_xact_tuples_hot_updated>, true, true, TArgs_pg_stat_get_xact_tuples_hot_updated_Policy>; }
-struct TArgs_pg_stat_get_xact_tuples_inserted_Policy {
+TExecFunc arrow_pg_has_role_name() { return TGenericExec<TPgDirectFunc<&pg_has_role_name>, true, true, TArgs_pg_has_role_name_Policy>({}); }
+struct TArgs_pg_has_role_name_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
 };
-TExecFunc arrow_pg_stat_get_xact_tuples_inserted() { return &GenericExec<TPgDirectFunc<&pg_stat_get_xact_tuples_inserted>, true, true, TArgs_pg_stat_get_xact_tuples_inserted_Policy>; }
-struct TArgs_pg_stat_get_xact_tuples_returned_Policy {
+TExecFunc arrow_pg_has_role_name_id() { return TGenericExec<TPgDirectFunc<&pg_has_role_name_id>, true, true, TArgs_pg_has_role_name_id_Policy>({}); }
+struct TArgs_pg_has_role_name_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
 };
-TExecFunc arrow_pg_stat_get_xact_tuples_returned() { return &GenericExec<TPgDirectFunc<&pg_stat_get_xact_tuples_returned>, true, true, TArgs_pg_stat_get_xact_tuples_returned_Policy>; }
-struct TArgs_pg_stat_get_xact_tuples_updated_Policy {
+TExecFunc arrow_pg_has_role_name_name() { return TGenericExec<TPgDirectFunc<&pg_has_role_name_name>, true, true, TArgs_pg_has_role_name_name_Policy>({}); }
+struct TArgs_pg_import_system_collations_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_stat_get_xact_tuples_updated() { return &GenericExec<TPgDirectFunc<&pg_stat_get_xact_tuples_updated>, true, true, TArgs_pg_stat_get_xact_tuples_updated_Policy>; }
-struct TArgs_pg_stat_reset_Policy {
+TExecFunc arrow_pg_import_system_collations() { return TGenericExec<TPgDirectFunc<&pg_import_system_collations>, true, true, TArgs_pg_import_system_collations_Policy>({}); }
+struct TArgs_pg_isolation_test_session_is_blocked_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_pg_stat_reset() { return &GenericExec<TPgDirectFunc<&pg_stat_reset>, false, true, TArgs_pg_stat_reset_Policy>; }
-struct TArgs_pg_stat_reset_replication_slot_Policy {
+TExecFunc arrow_pg_isolation_test_session_is_blocked() { return TGenericExec<TPgDirectFunc<&pg_isolation_test_session_is_blocked>, true, true, TArgs_pg_isolation_test_session_is_blocked_Policy>({}); }
+struct TArgs_pg_logical_emit_message_bytea_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
 };
-TExecFunc arrow_pg_stat_reset_replication_slot() { return &GenericExec<TPgDirectFunc<&pg_stat_reset_replication_slot>, false, true, TArgs_pg_stat_reset_replication_slot_Policy>; }
-struct TArgs_pg_stat_reset_shared_Policy {
+TExecFunc arrow_pg_logical_emit_message_bytea() { return TGenericExec<TPgDirectFunc<&pg_logical_emit_message_bytea>, true, true, TArgs_pg_logical_emit_message_bytea_Policy>({}); }
+struct TArgs_pg_logical_emit_message_text_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
+};
+TExecFunc arrow_pg_logical_emit_message_text() { return TGenericExec<TPgDirectFunc<&pg_logical_emit_message_text>, true, true, TArgs_pg_logical_emit_message_text_Policy>({}); }
+struct TArgs_pg_mcv_list_in_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_stat_reset_shared() { return &GenericExec<TPgDirectFunc<&pg_stat_reset_shared>, true, true, TArgs_pg_stat_reset_shared_Policy>; }
-struct TArgs_pg_stat_reset_single_function_counters_Policy {
+TExecFunc arrow_pg_mcv_list_in() { return TGenericExec<TPgDirectFunc<&pg_mcv_list_in>, true, false, TArgs_pg_mcv_list_in_Policy>({}); }
+struct TArgs_pg_mcv_list_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_stat_reset_single_function_counters() { return &GenericExec<TPgDirectFunc<&pg_stat_reset_single_function_counters>, true, true, TArgs_pg_stat_reset_single_function_counters_Policy>; }
-struct TArgs_pg_stat_reset_single_table_counters_Policy {
+TExecFunc arrow_pg_mcv_list_out() { return TGenericExec<TPgDirectFunc<&pg_mcv_list_out>, true, false, TArgs_pg_mcv_list_out_Policy>({}); }
+struct TArgs_pg_mcv_list_recv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_stat_reset_single_table_counters() { return &GenericExec<TPgDirectFunc<&pg_stat_reset_single_table_counters>, true, true, TArgs_pg_stat_reset_single_table_counters_Policy>; }
-struct TArgs_pg_stat_reset_slru_Policy {
+TExecFunc arrow_pg_mcv_list_recv() { return TGenericExec<TPgDirectFunc<&pg_mcv_list_recv>, true, false, TArgs_pg_mcv_list_recv_Policy>({}); }
+struct TArgs_pg_mcv_list_send_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_stat_reset_slru() { return &GenericExec<TPgDirectFunc<&pg_stat_reset_slru>, false, true, TArgs_pg_stat_reset_slru_Policy>; }
-struct TArgs_pg_table_size_Policy {
+TExecFunc arrow_pg_mcv_list_send() { return TGenericExec<TPgDirectFunc<&pg_mcv_list_send>, true, false, TArgs_pg_mcv_list_send_Policy>({}); }
+struct TArgs_pg_notification_queue_usage_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_pg_table_size() { return &GenericExec<TPgDirectFunc<&pg_table_size>, true, true, TArgs_pg_table_size_Policy>; }
-struct TArgs_pg_tablespace_location_Policy {
+TExecFunc arrow_pg_notification_queue_usage() { return TGenericExec<TPgDirectFunc<&pg_notification_queue_usage>, true, true, TArgs_pg_notification_queue_usage_Policy>({}); }
+struct TArgs_pg_notify_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_tablespace_location() { return &GenericExec<TPgDirectFunc<&pg_tablespace_location>, true, false, TArgs_pg_tablespace_location_Policy>; }
-struct TArgs_pg_tablespace_size_name_Policy {
+TExecFunc arrow_pg_notify() { return TGenericExec<TPgDirectFunc<&pg_notify>, false, true, TArgs_pg_notify_Policy>({}); }
+struct TArgs_pg_relation_is_publishable_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_tablespace_size_name() { return &GenericExec<TPgDirectFunc<&pg_tablespace_size_name>, true, true, TArgs_pg_tablespace_size_name_Policy>; }
-struct TArgs_pg_tablespace_size_oid_Policy {
+TExecFunc arrow_pg_relation_is_publishable() { return TGenericExec<TPgDirectFunc<&pg_relation_is_publishable>, true, true, TArgs_pg_relation_is_publishable_Policy>({}); }
+struct TArgs_pg_safe_snapshot_blocking_pids_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_tablespace_size_oid() { return &GenericExec<TPgDirectFunc<&pg_tablespace_size_oid>, true, true, TArgs_pg_tablespace_size_oid_Policy>; }
-struct TArgs_pg_total_relation_size_Policy {
+TExecFunc arrow_pg_safe_snapshot_blocking_pids() { return TGenericExec<TPgDirectFunc<&pg_safe_snapshot_blocking_pids>, true, false, TArgs_pg_safe_snapshot_blocking_pids_Policy>({}); }
+struct TArgs_pg_stat_get_wal_receiver_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_pg_total_relation_size() { return &GenericExec<TPgDirectFunc<&pg_total_relation_size>, true, true, TArgs_pg_total_relation_size_Policy>; }
-struct TArgs_pg_typeof_Policy {
+TExecFunc arrow_pg_stat_get_wal_receiver() { return TGenericExec<TPgDirectFunc<&pg_stat_get_wal_receiver>, false, false, TArgs_pg_stat_get_wal_receiver_Policy>({}); }
+struct TArgs_pg_try_advisory_lock_int4_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+};
+TExecFunc arrow_pg_try_advisory_lock_int4() { return TGenericExec<TPgDirectFunc<&pg_try_advisory_lock_int4>, true, true, TArgs_pg_try_advisory_lock_int4_Policy>({}); }
+struct TArgs_pg_try_advisory_lock_int8_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_typeof() { return &GenericExec<TPgDirectFunc<&pg_typeof>, false, true, TArgs_pg_typeof_Policy>; }
-struct TArgs_positionjoinsel_Policy {
+TExecFunc arrow_pg_try_advisory_lock_int8() { return TGenericExec<TPgDirectFunc<&pg_try_advisory_lock_int8>, true, true, TArgs_pg_try_advisory_lock_int8_Policy>({}); }
+struct TArgs_pg_try_advisory_lock_shared_int4_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_positionjoinsel() { return &GenericExec<TPgDirectFunc<&positionjoinsel>, true, true, TArgs_positionjoinsel_Policy>; }
-struct TArgs_positionsel_Policy {
+TExecFunc arrow_pg_try_advisory_lock_shared_int4() { return TGenericExec<TPgDirectFunc<&pg_try_advisory_lock_shared_int4>, true, true, TArgs_pg_try_advisory_lock_shared_int4_Policy>({}); }
+struct TArgs_pg_try_advisory_lock_shared_int8_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_positionsel() { return &GenericExec<TPgDirectFunc<&positionsel>, true, true, TArgs_positionsel_Policy>; }
-struct TArgs_postgresql_fdw_validator_Policy {
+TExecFunc arrow_pg_try_advisory_lock_shared_int8() { return TGenericExec<TPgDirectFunc<&pg_try_advisory_lock_shared_int8>, true, true, TArgs_pg_try_advisory_lock_shared_int8_Policy>({}); }
+struct TArgs_pg_try_advisory_xact_lock_int4_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_postgresql_fdw_validator() { return &GenericExec<TPgDirectFunc<&postgresql_fdw_validator>, true, true, TArgs_postgresql_fdw_validator_Policy>; }
-struct TArgs_range_adjacent_Policy {
+TExecFunc arrow_pg_try_advisory_xact_lock_int4() { return TGenericExec<TPgDirectFunc<&pg_try_advisory_xact_lock_int4>, true, true, TArgs_pg_try_advisory_xact_lock_int4_Policy>({}); }
+struct TArgs_pg_try_advisory_xact_lock_int8_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_range_adjacent() { return &GenericExec<TPgDirectFunc<&range_adjacent>, true, true, TArgs_range_adjacent_Policy>; }
-struct TArgs_range_after_Policy {
+TExecFunc arrow_pg_try_advisory_xact_lock_int8() { return TGenericExec<TPgDirectFunc<&pg_try_advisory_xact_lock_int8>, true, true, TArgs_pg_try_advisory_xact_lock_int8_Policy>({}); }
+struct TArgs_pg_try_advisory_xact_lock_shared_int4_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_range_after() { return &GenericExec<TPgDirectFunc<&range_after>, true, true, TArgs_range_after_Policy>; }
-struct TArgs_range_before_Policy {
+TExecFunc arrow_pg_try_advisory_xact_lock_shared_int4() { return TGenericExec<TPgDirectFunc<&pg_try_advisory_xact_lock_shared_int4>, true, true, TArgs_pg_try_advisory_xact_lock_shared_int4_Policy>({}); }
+struct TArgs_pg_try_advisory_xact_lock_shared_int8_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_range_before() { return &GenericExec<TPgDirectFunc<&range_before>, true, true, TArgs_range_before_Policy>; }
-struct TArgs_range_cmp_Policy {
+TExecFunc arrow_pg_try_advisory_xact_lock_shared_int8() { return TGenericExec<TPgDirectFunc<&pg_try_advisory_xact_lock_shared_int8>, true, true, TArgs_pg_try_advisory_xact_lock_shared_int8_Policy>({}); }
+struct TArgs_phraseto_tsquery_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_range_cmp() { return &GenericExec<TPgDirectFunc<&range_cmp>, true, true, TArgs_range_cmp_Policy>; }
-TExecFunc arrow_range_constructor2() { return &GenericExec<TPgDirectFunc<&range_constructor2>, false, false, TDefaultArgsPolicy>; }
-TExecFunc arrow_range_constructor3() { return &GenericExec<TPgDirectFunc<&range_constructor3>, false, false, TDefaultArgsPolicy>; }
-struct TArgs_range_contained_by_Policy {
+TExecFunc arrow_phraseto_tsquery() { return TGenericExec<TPgDirectFunc<&phraseto_tsquery>, true, false, TArgs_phraseto_tsquery_Policy>({}); }
+struct TArgs_phraseto_tsquery_byid_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_range_contained_by() { return &GenericExec<TPgDirectFunc<&range_contained_by>, true, true, TArgs_range_contained_by_Policy>; }
-struct TArgs_range_contains_Policy {
+TExecFunc arrow_phraseto_tsquery_byid() { return TGenericExec<TPgDirectFunc<&phraseto_tsquery_byid>, true, false, TArgs_phraseto_tsquery_byid_Policy>({}); }
+struct TArgs_plainto_tsquery_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_range_contains() { return &GenericExec<TPgDirectFunc<&range_contains>, true, true, TArgs_range_contains_Policy>; }
-struct TArgs_range_contains_elem_Policy {
+TExecFunc arrow_plainto_tsquery() { return TGenericExec<TPgDirectFunc<&plainto_tsquery>, true, false, TArgs_plainto_tsquery_Policy>({}); }
+struct TArgs_plainto_tsquery_byid_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_range_contains_elem() { return &GenericExec<TPgDirectFunc<&range_contains_elem>, true, true, TArgs_range_contains_elem_Policy>; }
-struct TArgs_range_empty_Policy {
+TExecFunc arrow_plainto_tsquery_byid() { return TGenericExec<TPgDirectFunc<&plainto_tsquery_byid>, true, false, TArgs_plainto_tsquery_byid_Policy>({}); }
+struct TArgs_query_to_xml_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,true,true,false};
 };
-TExecFunc arrow_range_empty() { return &GenericExec<TPgDirectFunc<&range_empty>, true, true, TArgs_range_empty_Policy>; }
-struct TArgs_range_eq_Policy {
+TExecFunc arrow_query_to_xml() { return TGenericExec<TPgDirectFunc<&query_to_xml>, true, false, TArgs_query_to_xml_Policy>({}); }
+struct TArgs_query_to_xml_and_xmlschema_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,true,true,false};
 };
-TExecFunc arrow_range_eq() { return &GenericExec<TPgDirectFunc<&range_eq>, true, true, TArgs_range_eq_Policy>; }
-struct TArgs_range_ge_Policy {
+TExecFunc arrow_query_to_xml_and_xmlschema() { return TGenericExec<TPgDirectFunc<&query_to_xml_and_xmlschema>, true, false, TArgs_query_to_xml_and_xmlschema_Policy>({}); }
+struct TArgs_query_to_xmlschema_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,true,true,false};
 };
-TExecFunc arrow_range_ge() { return &GenericExec<TPgDirectFunc<&range_ge>, true, true, TArgs_range_ge_Policy>; }
+TExecFunc arrow_query_to_xmlschema() { return TGenericExec<TPgDirectFunc<&query_to_xmlschema>, true, false, TArgs_query_to_xmlschema_Policy>({}); }
 struct TArgs_range_gist_consistent_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 5> IsFixedArg = {true,false,true,true,true};
 };
-TExecFunc arrow_range_gist_consistent() { return &GenericExec<TPgDirectFunc<&range_gist_consistent>, true, true, TArgs_range_gist_consistent_Policy>; }
+TExecFunc arrow_range_gist_consistent() { return TGenericExec<TPgDirectFunc<&range_gist_consistent>, true, true, TArgs_range_gist_consistent_Policy>({}); }
 struct TArgs_range_gist_penalty_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_range_gist_penalty() { return &GenericExec<TPgDirectFunc<&range_gist_penalty>, true, true, TArgs_range_gist_penalty_Policy>; }
+TExecFunc arrow_range_gist_penalty() { return TGenericExec<TPgDirectFunc<&range_gist_penalty>, true, true, TArgs_range_gist_penalty_Policy>({}); }
 struct TArgs_range_gist_picksplit_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_range_gist_picksplit() { return &GenericExec<TPgDirectFunc<&range_gist_picksplit>, true, true, TArgs_range_gist_picksplit_Policy>; }
+TExecFunc arrow_range_gist_picksplit() { return TGenericExec<TPgDirectFunc<&range_gist_picksplit>, true, true, TArgs_range_gist_picksplit_Policy>({}); }
 struct TArgs_range_gist_same_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {false,false,true};
 };
-TExecFunc arrow_range_gist_same() { return &GenericExec<TPgDirectFunc<&range_gist_same>, true, true, TArgs_range_gist_same_Policy>; }
+TExecFunc arrow_range_gist_same() { return TGenericExec<TPgDirectFunc<&range_gist_same>, true, true, TArgs_range_gist_same_Policy>({}); }
 struct TArgs_range_gist_union_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_range_gist_union() { return &GenericExec<TPgDirectFunc<&range_gist_union>, true, false, TArgs_range_gist_union_Policy>; }
-struct TArgs_range_gt_Policy {
+TExecFunc arrow_range_gist_union() { return TGenericExec<TPgDirectFunc<&range_gist_union>, true, false, TArgs_range_gist_union_Policy>({}); }
+struct TArgs_range_typanalyze_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_range_gt() { return &GenericExec<TPgDirectFunc<&range_gt>, true, true, TArgs_range_gt_Policy>; }
-struct TArgs_range_in_Policy {
+TExecFunc arrow_range_typanalyze() { return TGenericExec<TPgDirectFunc<&range_typanalyze>, true, true, TArgs_range_typanalyze_Policy>({}); }
+struct TArgs_replace_text_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
 };
-TExecFunc arrow_range_in() { return &GenericExec<TPgDirectFunc<&range_in>, true, false, TArgs_range_in_Policy>; }
-struct TArgs_range_intersect_Policy {
+TExecFunc arrow_replace_text() { return TGenericExec<TPgDirectFunc<&replace_text>, true, false, TArgs_replace_text_Policy>({}); }
+struct TArgs_schema_to_xml_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,true,true,false};
 };
-TExecFunc arrow_range_intersect() { return &GenericExec<TPgDirectFunc<&range_intersect>, true, false, TArgs_range_intersect_Policy>; }
-struct TArgs_range_intersect_agg_transfn_Policy {
+TExecFunc arrow_schema_to_xml() { return TGenericExec<TPgDirectFunc<&schema_to_xml>, true, false, TArgs_schema_to_xml_Policy>({}); }
+struct TArgs_schema_to_xml_and_xmlschema_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,true,true,false};
 };
-TExecFunc arrow_range_intersect_agg_transfn() { return &GenericExec<TPgDirectFunc<&range_intersect_agg_transfn>, true, false, TArgs_range_intersect_agg_transfn_Policy>; }
-struct TArgs_range_le_Policy {
+TExecFunc arrow_schema_to_xml_and_xmlschema() { return TGenericExec<TPgDirectFunc<&schema_to_xml_and_xmlschema>, true, false, TArgs_schema_to_xml_and_xmlschema_Policy>({}); }
+struct TArgs_schema_to_xmlschema_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,true,true,false};
 };
-TExecFunc arrow_range_le() { return &GenericExec<TPgDirectFunc<&range_le>, true, true, TArgs_range_le_Policy>; }
-struct TArgs_range_lower_Policy {
+TExecFunc arrow_schema_to_xmlschema() { return TGenericExec<TPgDirectFunc<&schema_to_xmlschema>, true, false, TArgs_schema_to_xmlschema_Policy>({}); }
+struct TArgs_spg_range_quad_choose_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_range_lower() { return &GenericExec<TPgDirectFunc<&range_lower>, true, true, TArgs_range_lower_Policy>; }
-struct TArgs_range_lower_inc_Policy {
+TExecFunc arrow_spg_range_quad_choose() { return TGenericExec<TPgDirectFunc<&spg_range_quad_choose>, true, true, TArgs_spg_range_quad_choose_Policy>({}); }
+struct TArgs_spg_range_quad_config_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_range_lower_inc() { return &GenericExec<TPgDirectFunc<&range_lower_inc>, true, true, TArgs_range_lower_inc_Policy>; }
-struct TArgs_range_lower_inf_Policy {
+TExecFunc arrow_spg_range_quad_config() { return TGenericExec<TPgDirectFunc<&spg_range_quad_config>, true, true, TArgs_spg_range_quad_config_Policy>({}); }
+struct TArgs_spg_range_quad_inner_consistent_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_range_lower_inf() { return &GenericExec<TPgDirectFunc<&range_lower_inf>, true, true, TArgs_range_lower_inf_Policy>; }
-struct TArgs_range_lt_Policy {
+TExecFunc arrow_spg_range_quad_inner_consistent() { return TGenericExec<TPgDirectFunc<&spg_range_quad_inner_consistent>, true, true, TArgs_spg_range_quad_inner_consistent_Policy>({}); }
+struct TArgs_spg_range_quad_leaf_consistent_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_range_lt() { return &GenericExec<TPgDirectFunc<&range_lt>, true, true, TArgs_range_lt_Policy>; }
-struct TArgs_range_merge_Policy {
+TExecFunc arrow_spg_range_quad_leaf_consistent() { return TGenericExec<TPgDirectFunc<&spg_range_quad_leaf_consistent>, true, true, TArgs_spg_range_quad_leaf_consistent_Policy>({}); }
+struct TArgs_spg_range_quad_picksplit_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_range_merge() { return &GenericExec<TPgDirectFunc<&range_merge>, true, false, TArgs_range_merge_Policy>; }
-struct TArgs_range_minus_Policy {
+TExecFunc arrow_spg_range_quad_picksplit() { return TGenericExec<TPgDirectFunc<&spg_range_quad_picksplit>, true, true, TArgs_spg_range_quad_picksplit_Policy>({}); }
+struct TArgs_split_part_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,true};
 };
-TExecFunc arrow_range_minus() { return &GenericExec<TPgDirectFunc<&range_minus>, true, false, TArgs_range_minus_Policy>; }
-struct TArgs_range_ne_Policy {
+TExecFunc arrow_split_part() { return TGenericExec<TPgDirectFunc<&split_part>, true, false, TArgs_split_part_Policy>({}); }
+struct TArgs_string_agg_finalfn_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_string_agg_finalfn() { return TGenericExec<TPgDirectFunc<&string_agg_finalfn>, false, false, TArgs_string_agg_finalfn_Policy>({}); }
+struct TArgs_string_agg_transfn_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
+};
+TExecFunc arrow_string_agg_transfn() { return TGenericExec<TPgDirectFunc<&string_agg_transfn>, false, true, TArgs_string_agg_transfn_Policy>({}); }
+struct TArgs_table_to_xml_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,false};
+};
+TExecFunc arrow_table_to_xml() { return TGenericExec<TPgDirectFunc<&table_to_xml>, true, false, TArgs_table_to_xml_Policy>({}); }
+struct TArgs_table_to_xml_and_xmlschema_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,false};
+};
+TExecFunc arrow_table_to_xml_and_xmlschema() { return TGenericExec<TPgDirectFunc<&table_to_xml_and_xmlschema>, true, false, TArgs_table_to_xml_and_xmlschema_Policy>({}); }
+struct TArgs_table_to_xmlschema_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,false};
 };
-TExecFunc arrow_range_ne() { return &GenericExec<TPgDirectFunc<&range_ne>, true, true, TArgs_range_ne_Policy>; }
-struct TArgs_range_out_Policy {
+TExecFunc arrow_table_to_xmlschema() { return TGenericExec<TPgDirectFunc<&table_to_xmlschema>, true, false, TArgs_table_to_xmlschema_Policy>({}); }
+struct TArgs_text_format_nv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_range_out() { return &GenericExec<TPgDirectFunc<&range_out>, true, false, TArgs_range_out_Policy>; }
-struct TArgs_range_overlaps_Policy {
+TExecFunc arrow_text_format_nv() { return TGenericExec<TPgDirectFunc<&text_format_nv>, false, false, TArgs_text_format_nv_Policy>({}); }
+struct TArgs_text_ge_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_range_overlaps() { return &GenericExec<TPgDirectFunc<&range_overlaps>, true, true, TArgs_range_overlaps_Policy>; }
-struct TArgs_range_overleft_Policy {
+TExecFunc arrow_text_ge() { return TGenericExec<TPgDirectFunc<&text_ge>, true, true, TArgs_text_ge_Policy>({}); }
+struct TArgs_text_gt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_range_overleft() { return &GenericExec<TPgDirectFunc<&range_overleft>, true, true, TArgs_range_overleft_Policy>; }
-struct TArgs_range_overright_Policy {
+TExecFunc arrow_text_gt() { return TGenericExec<TPgDirectFunc<&text_gt>, true, true, TArgs_text_gt_Policy>({}); }
+struct TArgs_text_larger_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_range_overright() { return &GenericExec<TPgDirectFunc<&range_overright>, true, true, TArgs_range_overright_Policy>; }
-struct TArgs_range_recv_Policy {
+TExecFunc arrow_text_larger() { return TGenericExec<TPgDirectFunc<&text_larger>, true, false, TArgs_text_larger_Policy>({}); }
+struct TArgs_text_le_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_range_recv() { return &GenericExec<TPgDirectFunc<&range_recv>, true, false, TArgs_range_recv_Policy>; }
-struct TArgs_range_send_Policy {
+TExecFunc arrow_text_le() { return TGenericExec<TPgDirectFunc<&text_le>, true, true, TArgs_text_le_Policy>({}); }
+struct TArgs_text_left_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_range_send() { return &GenericExec<TPgDirectFunc<&range_send>, true, false, TArgs_range_send_Policy>; }
-struct TArgs_range_union_Policy {
+TExecFunc arrow_text_left() { return TGenericExec<TPgDirectFunc<&text_left>, true, false, TArgs_text_left_Policy>({}); }
+struct TArgs_text_lt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_range_union() { return &GenericExec<TPgDirectFunc<&range_union>, true, false, TArgs_range_union_Policy>; }
-struct TArgs_range_upper_Policy {
+TExecFunc arrow_text_lt() { return TGenericExec<TPgDirectFunc<&text_lt>, true, true, TArgs_text_lt_Policy>({}); }
+struct TArgs_text_name_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_range_upper() { return &GenericExec<TPgDirectFunc<&range_upper>, true, true, TArgs_range_upper_Policy>; }
-struct TArgs_range_upper_inc_Policy {
+TExecFunc arrow_text_name() { return TGenericExec<TPgDirectFunc<&text_name>, true, false, TArgs_text_name_Policy>({}); }
+struct TArgs_text_pattern_ge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_range_upper_inc() { return &GenericExec<TPgDirectFunc<&range_upper_inc>, true, true, TArgs_range_upper_inc_Policy>; }
-struct TArgs_range_upper_inf_Policy {
+TExecFunc arrow_text_pattern_ge() { return TGenericExec<TPgDirectFunc<&text_pattern_ge>, true, true, TArgs_text_pattern_ge_Policy>({}); }
+struct TArgs_text_pattern_gt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_range_upper_inf() { return &GenericExec<TPgDirectFunc<&range_upper_inf>, true, true, TArgs_range_upper_inf_Policy>; }
-struct TArgs_record_eq_Policy {
+TExecFunc arrow_text_pattern_gt() { return TGenericExec<TPgDirectFunc<&text_pattern_gt>, true, true, TArgs_text_pattern_gt_Policy>({}); }
+struct TArgs_text_pattern_le_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_record_eq() { return &GenericExec<TPgDirectFunc<&record_eq>, true, true, TArgs_record_eq_Policy>; }
-struct TArgs_record_ge_Policy {
+TExecFunc arrow_text_pattern_le() { return TGenericExec<TPgDirectFunc<&text_pattern_le>, true, true, TArgs_text_pattern_le_Policy>({}); }
+struct TArgs_text_pattern_lt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_record_ge() { return &GenericExec<TPgDirectFunc<&record_ge>, true, true, TArgs_record_ge_Policy>; }
-struct TArgs_record_gt_Policy {
+TExecFunc arrow_text_pattern_lt() { return TGenericExec<TPgDirectFunc<&text_pattern_lt>, true, true, TArgs_text_pattern_lt_Policy>({}); }
+struct TArgs_text_reverse_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_record_gt() { return &GenericExec<TPgDirectFunc<&record_gt>, true, true, TArgs_record_gt_Policy>; }
-struct TArgs_record_image_eq_Policy {
+TExecFunc arrow_text_reverse() { return TGenericExec<TPgDirectFunc<&text_reverse>, true, false, TArgs_text_reverse_Policy>({}); }
+struct TArgs_text_right_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_record_image_eq() { return &GenericExec<TPgDirectFunc<&record_image_eq>, true, true, TArgs_record_image_eq_Policy>; }
-struct TArgs_record_image_ge_Policy {
+TExecFunc arrow_text_right() { return TGenericExec<TPgDirectFunc<&text_right>, true, false, TArgs_text_right_Policy>({}); }
+struct TArgs_text_smaller_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_record_image_ge() { return &GenericExec<TPgDirectFunc<&record_image_ge>, true, true, TArgs_record_image_ge_Policy>; }
-struct TArgs_record_image_gt_Policy {
+TExecFunc arrow_text_smaller() { return TGenericExec<TPgDirectFunc<&text_smaller>, true, false, TArgs_text_smaller_Policy>({}); }
+struct TArgs_text_starts_with_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_record_image_gt() { return &GenericExec<TPgDirectFunc<&record_image_gt>, true, true, TArgs_record_image_gt_Policy>; }
-struct TArgs_record_image_le_Policy {
+TExecFunc arrow_text_starts_with() { return TGenericExec<TPgDirectFunc<&text_starts_with>, true, true, TArgs_text_starts_with_Policy>({}); }
+struct TArgs_text_substr_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_record_image_le() { return &GenericExec<TPgDirectFunc<&record_image_le>, true, true, TArgs_record_image_le_Policy>; }
-struct TArgs_record_image_lt_Policy {
+TExecFunc arrow_text_substr() { return TGenericExec<TPgDirectFunc<&text_substr>, true, false, TArgs_text_substr_Policy>({}); }
+struct TArgs_text_substr_no_len_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_record_image_lt() { return &GenericExec<TPgDirectFunc<&record_image_lt>, true, true, TArgs_record_image_lt_Policy>; }
-struct TArgs_record_image_ne_Policy {
+TExecFunc arrow_text_substr_no_len() { return TGenericExec<TPgDirectFunc<&text_substr_no_len>, true, false, TArgs_text_substr_no_len_Policy>({}); }
+struct TArgs_text_to_array_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_record_image_ne() { return &GenericExec<TPgDirectFunc<&record_image_ne>, true, true, TArgs_record_image_ne_Policy>; }
-struct TArgs_record_in_Policy {
+TExecFunc arrow_text_to_array() { return TGenericExec<TPgDirectFunc<&text_to_array>, false, false, TArgs_text_to_array_Policy>({}); }
+struct TArgs_text_to_array_null_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
 };
-TExecFunc arrow_record_in() { return &GenericExec<TPgDirectFunc<&record_in>, true, false, TArgs_record_in_Policy>; }
-struct TArgs_record_le_Policy {
+TExecFunc arrow_text_to_array_null() { return TGenericExec<TPgDirectFunc<&text_to_array_null>, false, false, TArgs_text_to_array_null_Policy>({}); }
+struct TArgs_textcat_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_record_le() { return &GenericExec<TPgDirectFunc<&record_le>, true, true, TArgs_record_le_Policy>; }
-struct TArgs_record_lt_Policy {
+TExecFunc arrow_textcat() { return TGenericExec<TPgDirectFunc<&textcat>, true, false, TArgs_textcat_Policy>({}); }
+struct TArgs_texteq_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_record_lt() { return &GenericExec<TPgDirectFunc<&record_lt>, true, true, TArgs_record_lt_Policy>; }
-struct TArgs_record_ne_Policy {
+TExecFunc arrow_texteq() { return TGenericExec<TPgDirectFunc<&texteq>, true, true, TArgs_texteq_Policy>({}); }
+struct TArgs_texteqname_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_record_ne() { return &GenericExec<TPgDirectFunc<&record_ne>, true, true, TArgs_record_ne_Policy>; }
-struct TArgs_record_out_Policy {
+TExecFunc arrow_texteqname() { return TGenericExec<TPgDirectFunc<&texteqname>, true, true, TArgs_texteqname_Policy>({}); }
+struct TArgs_textgename_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_record_out() { return &GenericExec<TPgDirectFunc<&record_out>, true, false, TArgs_record_out_Policy>; }
-struct TArgs_record_recv_Policy {
+TExecFunc arrow_textgename() { return TGenericExec<TPgDirectFunc<&textgename>, true, true, TArgs_textgename_Policy>({}); }
+struct TArgs_textgtname_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_record_recv() { return &GenericExec<TPgDirectFunc<&record_recv>, true, false, TArgs_record_recv_Policy>; }
-struct TArgs_record_send_Policy {
+TExecFunc arrow_textgtname() { return TGenericExec<TPgDirectFunc<&textgtname>, true, true, TArgs_textgtname_Policy>({}); }
+struct TArgs_textin_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_record_send() { return &GenericExec<TPgDirectFunc<&record_send>, true, false, TArgs_record_send_Policy>; }
-struct TArgs_session_user_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
-};
-TExecFunc arrow_session_user() { return &GenericExec<TPgDirectFunc<&session_user>, true, false, TArgs_session_user_Policy>; }
-struct TArgs_setval3_oid_Policy {
+TExecFunc arrow_textin() { return TGenericExec<TPgDirectFunc<&textin>, true, false, TArgs_textin_Policy>({}); }
+struct TArgs_textlen_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_setval3_oid() { return &GenericExec<TPgDirectFunc<&setval3_oid>, true, true, TArgs_setval3_oid_Policy>; }
-struct TArgs_setval_oid_Policy {
+TExecFunc arrow_textlen() { return TGenericExec<TPgDirectFunc<&textlen>, true, true, TArgs_textlen_Policy>({}); }
+struct TArgs_textlename_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_setval_oid() { return &GenericExec<TPgDirectFunc<&setval_oid>, true, true, TArgs_setval_oid_Policy>; }
-struct TArgs_tideq_Policy {
+TExecFunc arrow_textlename() { return TGenericExec<TPgDirectFunc<&textlename>, true, true, TArgs_textlename_Policy>({}); }
+struct TArgs_textltname_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_tideq() { return &GenericExec<TPgDirectFunc<&tideq>, true, true, TArgs_tideq_Policy>; }
-struct TArgs_tidge_Policy {
+TExecFunc arrow_textltname() { return TGenericExec<TPgDirectFunc<&textltname>, true, true, TArgs_textltname_Policy>({}); }
+struct TArgs_textne_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_tidge() { return &GenericExec<TPgDirectFunc<&tidge>, true, true, TArgs_tidge_Policy>; }
-struct TArgs_tidgt_Policy {
+TExecFunc arrow_textne() { return TGenericExec<TPgDirectFunc<&textne>, true, true, TArgs_textne_Policy>({}); }
+struct TArgs_textnename_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_tidgt() { return &GenericExec<TPgDirectFunc<&tidgt>, true, true, TArgs_tidgt_Policy>; }
-struct TArgs_tidin_Policy {
+TExecFunc arrow_textnename() { return TGenericExec<TPgDirectFunc<&textnename>, true, true, TArgs_textnename_Policy>({}); }
+struct TArgs_textoctetlen_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_tidin() { return &GenericExec<TPgDirectFunc<&tidin>, true, false, TArgs_tidin_Policy>; }
-struct TArgs_tidlarger_Policy {
+TExecFunc arrow_textoctetlen() { return TGenericExec<TPgDirectFunc<&textoctetlen>, true, true, TArgs_textoctetlen_Policy>({}); }
+struct TArgs_textout_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_tidlarger() { return &GenericExec<TPgDirectFunc<&tidlarger>, true, false, TArgs_tidlarger_Policy>; }
-struct TArgs_tidle_Policy {
+TExecFunc arrow_textout() { return TGenericExec<TPgDirectFunc<&textout>, true, false, TArgs_textout_Policy>({}); }
+struct TArgs_textoverlay_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,false,true,true};
 };
-TExecFunc arrow_tidle() { return &GenericExec<TPgDirectFunc<&tidle>, true, true, TArgs_tidle_Policy>; }
-struct TArgs_tidlt_Policy {
+TExecFunc arrow_textoverlay() { return TGenericExec<TPgDirectFunc<&textoverlay>, true, false, TArgs_textoverlay_Policy>({}); }
+struct TArgs_textoverlay_no_len_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,true};
 };
-TExecFunc arrow_tidlt() { return &GenericExec<TPgDirectFunc<&tidlt>, true, true, TArgs_tidlt_Policy>; }
-struct TArgs_tidne_Policy {
+TExecFunc arrow_textoverlay_no_len() { return TGenericExec<TPgDirectFunc<&textoverlay_no_len>, true, false, TArgs_textoverlay_no_len_Policy>({}); }
+struct TArgs_textpos_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_tidne() { return &GenericExec<TPgDirectFunc<&tidne>, true, true, TArgs_tidne_Policy>; }
-struct TArgs_tidout_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_tidout() { return &GenericExec<TPgDirectFunc<&tidout>, true, false, TArgs_tidout_Policy>; }
-struct TArgs_tidrecv_Policy {
+TExecFunc arrow_textpos() { return TGenericExec<TPgDirectFunc<&textpos>, true, true, TArgs_textpos_Policy>({}); }
+struct TArgs_textrecv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_tidrecv() { return &GenericExec<TPgDirectFunc<&tidrecv>, true, false, TArgs_tidrecv_Policy>; }
-struct TArgs_tidsend_Policy {
+TExecFunc arrow_textrecv() { return TGenericExec<TPgDirectFunc<&textrecv>, true, false, TArgs_textrecv_Policy>({}); }
+struct TArgs_textsend_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_tidsend() { return &GenericExec<TPgDirectFunc<&tidsend>, true, false, TArgs_tidsend_Policy>; }
-struct TArgs_tidsmaller_Policy {
+TExecFunc arrow_textsend() { return TGenericExec<TPgDirectFunc<&textsend>, true, false, TArgs_textsend_Policy>({}); }
+struct TArgs_texttoxml_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_tidsmaller() { return &GenericExec<TPgDirectFunc<&tidsmaller>, true, false, TArgs_tidsmaller_Policy>; }
+TExecFunc arrow_texttoxml() { return TGenericExec<TPgDirectFunc<&texttoxml>, true, false, TArgs_texttoxml_Policy>({}); }
 struct TArgs_time_cmp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_time_cmp() { return &GenericExec<TPgDirectFunc<&time_cmp>, true, true, TArgs_time_cmp_Policy>; }
+TExecFunc arrow_time_cmp() { return TGenericExec<TPgDirectFunc<&time_cmp>, true, true, TArgs_time_cmp_Policy>({}); }
 struct TArgs_time_eq_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_time_eq() { return &GenericExec<TPgDirectFunc<&time_eq>, true, true, TArgs_time_eq_Policy>; }
+TExecFunc arrow_time_eq() { return TGenericExec<TPgDirectFunc<&time_eq>, true, true, TArgs_time_eq_Policy>({}); }
 struct TArgs_time_ge_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_time_ge() { return &GenericExec<TPgDirectFunc<&time_ge>, true, true, TArgs_time_ge_Policy>; }
+TExecFunc arrow_time_ge() { return TGenericExec<TPgDirectFunc<&time_ge>, true, true, TArgs_time_ge_Policy>({}); }
 struct TArgs_time_gt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_time_gt() { return &GenericExec<TPgDirectFunc<&time_gt>, true, true, TArgs_time_gt_Policy>; }
+TExecFunc arrow_time_gt() { return TGenericExec<TPgDirectFunc<&time_gt>, true, true, TArgs_time_gt_Policy>({}); }
 struct TArgs_time_hash_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_time_hash() { return &GenericExec<TPgDirectFunc<&time_hash>, true, true, TArgs_time_hash_Policy>; }
+TExecFunc arrow_time_hash() { return TGenericExec<TPgDirectFunc<&time_hash>, true, true, TArgs_time_hash_Policy>({}); }
 struct TArgs_time_hash_extended_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_time_hash_extended() { return &GenericExec<TPgDirectFunc<&time_hash_extended>, true, true, TArgs_time_hash_extended_Policy>; }
+TExecFunc arrow_time_hash_extended() { return TGenericExec<TPgDirectFunc<&time_hash_extended>, true, true, TArgs_time_hash_extended_Policy>({}); }
 struct TArgs_time_in_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_time_in() { return &GenericExec<TPgDirectFunc<&time_in>, true, true, TArgs_time_in_Policy>; }
+TExecFunc arrow_time_in() { return TGenericExec<TPgDirectFunc<&time_in>, true, true, TArgs_time_in_Policy>({}); }
 struct TArgs_time_interval_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_time_interval() { return &GenericExec<TPgDirectFunc<&time_interval>, true, false, TArgs_time_interval_Policy>; }
+TExecFunc arrow_time_interval() { return TGenericExec<TPgDirectFunc<&time_interval>, true, false, TArgs_time_interval_Policy>({}); }
 struct TArgs_time_larger_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_time_larger() { return &GenericExec<TPgDirectFunc<&time_larger>, true, true, TArgs_time_larger_Policy>; }
+TExecFunc arrow_time_larger() { return TGenericExec<TPgDirectFunc<&time_larger>, true, true, TArgs_time_larger_Policy>({}); }
 struct TArgs_time_le_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_time_le() { return &GenericExec<TPgDirectFunc<&time_le>, true, true, TArgs_time_le_Policy>; }
+TExecFunc arrow_time_le() { return TGenericExec<TPgDirectFunc<&time_le>, true, true, TArgs_time_le_Policy>({}); }
 struct TArgs_time_lt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_time_lt() { return &GenericExec<TPgDirectFunc<&time_lt>, true, true, TArgs_time_lt_Policy>; }
+TExecFunc arrow_time_lt() { return TGenericExec<TPgDirectFunc<&time_lt>, true, true, TArgs_time_lt_Policy>({}); }
 struct TArgs_time_mi_interval_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_time_mi_interval() { return &GenericExec<TPgDirectFunc<&time_mi_interval>, true, true, TArgs_time_mi_interval_Policy>; }
+TExecFunc arrow_time_mi_interval() { return TGenericExec<TPgDirectFunc<&time_mi_interval>, true, true, TArgs_time_mi_interval_Policy>({}); }
 struct TArgs_time_mi_time_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_time_mi_time() { return &GenericExec<TPgDirectFunc<&time_mi_time>, true, false, TArgs_time_mi_time_Policy>; }
+TExecFunc arrow_time_mi_time() { return TGenericExec<TPgDirectFunc<&time_mi_time>, true, false, TArgs_time_mi_time_Policy>({}); }
 struct TArgs_time_ne_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_time_ne() { return &GenericExec<TPgDirectFunc<&time_ne>, true, true, TArgs_time_ne_Policy>; }
+TExecFunc arrow_time_ne() { return TGenericExec<TPgDirectFunc<&time_ne>, true, true, TArgs_time_ne_Policy>({}); }
 struct TArgs_time_out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_time_out() { return &GenericExec<TPgDirectFunc<&time_out>, true, false, TArgs_time_out_Policy>; }
+TExecFunc arrow_time_out() { return TGenericExec<TPgDirectFunc<&time_out>, true, false, TArgs_time_out_Policy>({}); }
 struct TArgs_time_part_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_time_part() { return &GenericExec<TPgDirectFunc<&time_part>, true, true, TArgs_time_part_Policy>; }
+TExecFunc arrow_time_part() { return TGenericExec<TPgDirectFunc<&time_part>, true, true, TArgs_time_part_Policy>({}); }
 struct TArgs_time_pl_interval_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_time_pl_interval() { return &GenericExec<TPgDirectFunc<&time_pl_interval>, true, true, TArgs_time_pl_interval_Policy>; }
+TExecFunc arrow_time_pl_interval() { return TGenericExec<TPgDirectFunc<&time_pl_interval>, true, true, TArgs_time_pl_interval_Policy>({}); }
 struct TArgs_time_recv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_time_recv() { return &GenericExec<TPgDirectFunc<&time_recv>, true, true, TArgs_time_recv_Policy>; }
+TExecFunc arrow_time_recv() { return TGenericExec<TPgDirectFunc<&time_recv>, true, true, TArgs_time_recv_Policy>({}); }
 struct TArgs_time_scale_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_time_scale() { return &GenericExec<TPgDirectFunc<&time_scale>, true, true, TArgs_time_scale_Policy>; }
+TExecFunc arrow_time_scale() { return TGenericExec<TPgDirectFunc<&time_scale>, true, true, TArgs_time_scale_Policy>({}); }
 struct TArgs_time_send_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_time_send() { return &GenericExec<TPgDirectFunc<&time_send>, true, false, TArgs_time_send_Policy>; }
+TExecFunc arrow_time_send() { return TGenericExec<TPgDirectFunc<&time_send>, true, false, TArgs_time_send_Policy>({}); }
 struct TArgs_time_smaller_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_time_smaller() { return &GenericExec<TPgDirectFunc<&time_smaller>, true, true, TArgs_time_smaller_Policy>; }
+TExecFunc arrow_time_smaller() { return TGenericExec<TPgDirectFunc<&time_smaller>, true, true, TArgs_time_smaller_Policy>({}); }
 struct TArgs_time_support_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_time_support() { return &GenericExec<TPgDirectFunc<&time_support>, true, true, TArgs_time_support_Policy>; }
+TExecFunc arrow_time_support() { return TGenericExec<TPgDirectFunc<&time_support>, true, true, TArgs_time_support_Policy>({}); }
 struct TArgs_time_timetz_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_time_timetz() { return &GenericExec<TPgDirectFunc<&time_timetz>, true, false, TArgs_time_timetz_Policy>; }
+TExecFunc arrow_time_timetz() { return TGenericExec<TPgDirectFunc<&time_timetz>, true, false, TArgs_time_timetz_Policy>({}); }
 struct TArgs_timestamp_cmp_date_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_timestamp_cmp_date() { return &GenericExec<TPgDirectFunc<&timestamp_cmp_date>, true, true, TArgs_timestamp_cmp_date_Policy>; }
+TExecFunc arrow_timestamp_cmp_date() { return TGenericExec<TPgDirectFunc<&timestamp_cmp_date>, true, true, TArgs_timestamp_cmp_date_Policy>({}); }
 struct TArgs_timestamp_date_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_timestamp_date() { return &GenericExec<TPgDirectFunc<&timestamp_date>, true, true, TArgs_timestamp_date_Policy>; }
+TExecFunc arrow_timestamp_date() { return TGenericExec<TPgDirectFunc<&timestamp_date>, true, true, TArgs_timestamp_date_Policy>({}); }
 struct TArgs_timestamp_eq_date_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_timestamp_eq_date() { return &GenericExec<TPgDirectFunc<&timestamp_eq_date>, true, true, TArgs_timestamp_eq_date_Policy>; }
+TExecFunc arrow_timestamp_eq_date() { return TGenericExec<TPgDirectFunc<&timestamp_eq_date>, true, true, TArgs_timestamp_eq_date_Policy>({}); }
 struct TArgs_timestamp_ge_date_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_timestamp_ge_date() { return &GenericExec<TPgDirectFunc<&timestamp_ge_date>, true, true, TArgs_timestamp_ge_date_Policy>; }
+TExecFunc arrow_timestamp_ge_date() { return TGenericExec<TPgDirectFunc<&timestamp_ge_date>, true, true, TArgs_timestamp_ge_date_Policy>({}); }
 struct TArgs_timestamp_gt_date_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_timestamp_gt_date() { return &GenericExec<TPgDirectFunc<&timestamp_gt_date>, true, true, TArgs_timestamp_gt_date_Policy>; }
+TExecFunc arrow_timestamp_gt_date() { return TGenericExec<TPgDirectFunc<&timestamp_gt_date>, true, true, TArgs_timestamp_gt_date_Policy>({}); }
 struct TArgs_timestamp_le_date_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_timestamp_le_date() { return &GenericExec<TPgDirectFunc<&timestamp_le_date>, true, true, TArgs_timestamp_le_date_Policy>; }
+TExecFunc arrow_timestamp_le_date() { return TGenericExec<TPgDirectFunc<&timestamp_le_date>, true, true, TArgs_timestamp_le_date_Policy>({}); }
 struct TArgs_timestamp_lt_date_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_timestamp_lt_date() { return &GenericExec<TPgDirectFunc<&timestamp_lt_date>, true, true, TArgs_timestamp_lt_date_Policy>; }
+TExecFunc arrow_timestamp_lt_date() { return TGenericExec<TPgDirectFunc<&timestamp_lt_date>, true, true, TArgs_timestamp_lt_date_Policy>({}); }
 struct TArgs_timestamp_ne_date_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_timestamp_ne_date() { return &GenericExec<TPgDirectFunc<&timestamp_ne_date>, true, true, TArgs_timestamp_ne_date_Policy>; }
+TExecFunc arrow_timestamp_ne_date() { return TGenericExec<TPgDirectFunc<&timestamp_ne_date>, true, true, TArgs_timestamp_ne_date_Policy>({}); }
 struct TArgs_timestamp_time_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_timestamp_time() { return &GenericExec<TPgDirectFunc<&timestamp_time>, true, true, TArgs_timestamp_time_Policy>; }
+TExecFunc arrow_timestamp_time() { return TGenericExec<TPgDirectFunc<&timestamp_time>, true, true, TArgs_timestamp_time_Policy>({}); }
 struct TArgs_timestamptz_cmp_date_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_timestamptz_cmp_date() { return &GenericExec<TPgDirectFunc<&timestamptz_cmp_date>, true, true, TArgs_timestamptz_cmp_date_Policy>; }
+TExecFunc arrow_timestamptz_cmp_date() { return TGenericExec<TPgDirectFunc<&timestamptz_cmp_date>, true, true, TArgs_timestamptz_cmp_date_Policy>({}); }
 struct TArgs_timestamptz_date_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_timestamptz_date() { return &GenericExec<TPgDirectFunc<&timestamptz_date>, true, true, TArgs_timestamptz_date_Policy>; }
+TExecFunc arrow_timestamptz_date() { return TGenericExec<TPgDirectFunc<&timestamptz_date>, true, true, TArgs_timestamptz_date_Policy>({}); }
 struct TArgs_timestamptz_eq_date_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_timestamptz_eq_date() { return &GenericExec<TPgDirectFunc<&timestamptz_eq_date>, true, true, TArgs_timestamptz_eq_date_Policy>; }
+TExecFunc arrow_timestamptz_eq_date() { return TGenericExec<TPgDirectFunc<&timestamptz_eq_date>, true, true, TArgs_timestamptz_eq_date_Policy>({}); }
 struct TArgs_timestamptz_ge_date_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_timestamptz_ge_date() { return &GenericExec<TPgDirectFunc<&timestamptz_ge_date>, true, true, TArgs_timestamptz_ge_date_Policy>; }
+TExecFunc arrow_timestamptz_ge_date() { return TGenericExec<TPgDirectFunc<&timestamptz_ge_date>, true, true, TArgs_timestamptz_ge_date_Policy>({}); }
 struct TArgs_timestamptz_gt_date_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_timestamptz_gt_date() { return &GenericExec<TPgDirectFunc<&timestamptz_gt_date>, true, true, TArgs_timestamptz_gt_date_Policy>; }
+TExecFunc arrow_timestamptz_gt_date() { return TGenericExec<TPgDirectFunc<&timestamptz_gt_date>, true, true, TArgs_timestamptz_gt_date_Policy>({}); }
 struct TArgs_timestamptz_le_date_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_timestamptz_le_date() { return &GenericExec<TPgDirectFunc<&timestamptz_le_date>, true, true, TArgs_timestamptz_le_date_Policy>; }
+TExecFunc arrow_timestamptz_le_date() { return TGenericExec<TPgDirectFunc<&timestamptz_le_date>, true, true, TArgs_timestamptz_le_date_Policy>({}); }
 struct TArgs_timestamptz_lt_date_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_timestamptz_lt_date() { return &GenericExec<TPgDirectFunc<&timestamptz_lt_date>, true, true, TArgs_timestamptz_lt_date_Policy>; }
+TExecFunc arrow_timestamptz_lt_date() { return TGenericExec<TPgDirectFunc<&timestamptz_lt_date>, true, true, TArgs_timestamptz_lt_date_Policy>({}); }
 struct TArgs_timestamptz_ne_date_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_timestamptz_ne_date() { return &GenericExec<TPgDirectFunc<&timestamptz_ne_date>, true, true, TArgs_timestamptz_ne_date_Policy>; }
+TExecFunc arrow_timestamptz_ne_date() { return TGenericExec<TPgDirectFunc<&timestamptz_ne_date>, true, true, TArgs_timestamptz_ne_date_Policy>({}); }
 struct TArgs_timestamptz_time_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_timestamptz_time() { return &GenericExec<TPgDirectFunc<&timestamptz_time>, true, true, TArgs_timestamptz_time_Policy>; }
+TExecFunc arrow_timestamptz_time() { return TGenericExec<TPgDirectFunc<&timestamptz_time>, true, true, TArgs_timestamptz_time_Policy>({}); }
 struct TArgs_timestamptz_timetz_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_timestamptz_timetz() { return &GenericExec<TPgDirectFunc<&timestamptz_timetz>, true, false, TArgs_timestamptz_timetz_Policy>; }
+TExecFunc arrow_timestamptz_timetz() { return TGenericExec<TPgDirectFunc<&timestamptz_timetz>, true, false, TArgs_timestamptz_timetz_Policy>({}); }
 struct TArgs_timetypmodin_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_timetypmodin() { return &GenericExec<TPgDirectFunc<&timetypmodin>, true, true, TArgs_timetypmodin_Policy>; }
+TExecFunc arrow_timetypmodin() { return TGenericExec<TPgDirectFunc<&timetypmodin>, true, true, TArgs_timetypmodin_Policy>({}); }
 struct TArgs_timetypmodout_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_timetypmodout() { return &GenericExec<TPgDirectFunc<&timetypmodout>, true, false, TArgs_timetypmodout_Policy>; }
+TExecFunc arrow_timetypmodout() { return TGenericExec<TPgDirectFunc<&timetypmodout>, true, false, TArgs_timetypmodout_Policy>({}); }
 struct TArgs_timetz_cmp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timetz_cmp() { return &GenericExec<TPgDirectFunc<&timetz_cmp>, true, true, TArgs_timetz_cmp_Policy>; }
+TExecFunc arrow_timetz_cmp() { return TGenericExec<TPgDirectFunc<&timetz_cmp>, true, true, TArgs_timetz_cmp_Policy>({}); }
 struct TArgs_timetz_eq_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timetz_eq() { return &GenericExec<TPgDirectFunc<&timetz_eq>, true, true, TArgs_timetz_eq_Policy>; }
+TExecFunc arrow_timetz_eq() { return TGenericExec<TPgDirectFunc<&timetz_eq>, true, true, TArgs_timetz_eq_Policy>({}); }
 struct TArgs_timetz_ge_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timetz_ge() { return &GenericExec<TPgDirectFunc<&timetz_ge>, true, true, TArgs_timetz_ge_Policy>; }
+TExecFunc arrow_timetz_ge() { return TGenericExec<TPgDirectFunc<&timetz_ge>, true, true, TArgs_timetz_ge_Policy>({}); }
 struct TArgs_timetz_gt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timetz_gt() { return &GenericExec<TPgDirectFunc<&timetz_gt>, true, true, TArgs_timetz_gt_Policy>; }
+TExecFunc arrow_timetz_gt() { return TGenericExec<TPgDirectFunc<&timetz_gt>, true, true, TArgs_timetz_gt_Policy>({}); }
 struct TArgs_timetz_hash_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_timetz_hash() { return &GenericExec<TPgDirectFunc<&timetz_hash>, true, true, TArgs_timetz_hash_Policy>; }
+TExecFunc arrow_timetz_hash() { return TGenericExec<TPgDirectFunc<&timetz_hash>, true, true, TArgs_timetz_hash_Policy>({}); }
 struct TArgs_timetz_hash_extended_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_timetz_hash_extended() { return &GenericExec<TPgDirectFunc<&timetz_hash_extended>, true, true, TArgs_timetz_hash_extended_Policy>; }
+TExecFunc arrow_timetz_hash_extended() { return TGenericExec<TPgDirectFunc<&timetz_hash_extended>, true, true, TArgs_timetz_hash_extended_Policy>({}); }
 struct TArgs_timetz_in_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_timetz_in() { return &GenericExec<TPgDirectFunc<&timetz_in>, true, false, TArgs_timetz_in_Policy>; }
+TExecFunc arrow_timetz_in() { return TGenericExec<TPgDirectFunc<&timetz_in>, true, false, TArgs_timetz_in_Policy>({}); }
 struct TArgs_timetz_izone_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timetz_izone() { return &GenericExec<TPgDirectFunc<&timetz_izone>, true, false, TArgs_timetz_izone_Policy>; }
+TExecFunc arrow_timetz_izone() { return TGenericExec<TPgDirectFunc<&timetz_izone>, true, false, TArgs_timetz_izone_Policy>({}); }
 struct TArgs_timetz_larger_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timetz_larger() { return &GenericExec<TPgDirectFunc<&timetz_larger>, true, false, TArgs_timetz_larger_Policy>; }
+TExecFunc arrow_timetz_larger() { return TGenericExec<TPgDirectFunc<&timetz_larger>, true, false, TArgs_timetz_larger_Policy>({}); }
 struct TArgs_timetz_le_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timetz_le() { return &GenericExec<TPgDirectFunc<&timetz_le>, true, true, TArgs_timetz_le_Policy>; }
+TExecFunc arrow_timetz_le() { return TGenericExec<TPgDirectFunc<&timetz_le>, true, true, TArgs_timetz_le_Policy>({}); }
 struct TArgs_timetz_lt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timetz_lt() { return &GenericExec<TPgDirectFunc<&timetz_lt>, true, true, TArgs_timetz_lt_Policy>; }
+TExecFunc arrow_timetz_lt() { return TGenericExec<TPgDirectFunc<&timetz_lt>, true, true, TArgs_timetz_lt_Policy>({}); }
 struct TArgs_timetz_mi_interval_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timetz_mi_interval() { return &GenericExec<TPgDirectFunc<&timetz_mi_interval>, true, false, TArgs_timetz_mi_interval_Policy>; }
+TExecFunc arrow_timetz_mi_interval() { return TGenericExec<TPgDirectFunc<&timetz_mi_interval>, true, false, TArgs_timetz_mi_interval_Policy>({}); }
 struct TArgs_timetz_ne_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timetz_ne() { return &GenericExec<TPgDirectFunc<&timetz_ne>, true, true, TArgs_timetz_ne_Policy>; }
+TExecFunc arrow_timetz_ne() { return TGenericExec<TPgDirectFunc<&timetz_ne>, true, true, TArgs_timetz_ne_Policy>({}); }
 struct TArgs_timetz_out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_timetz_out() { return &GenericExec<TPgDirectFunc<&timetz_out>, true, false, TArgs_timetz_out_Policy>; }
+TExecFunc arrow_timetz_out() { return TGenericExec<TPgDirectFunc<&timetz_out>, true, false, TArgs_timetz_out_Policy>({}); }
 struct TArgs_timetz_part_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timetz_part() { return &GenericExec<TPgDirectFunc<&timetz_part>, true, true, TArgs_timetz_part_Policy>; }
+TExecFunc arrow_timetz_part() { return TGenericExec<TPgDirectFunc<&timetz_part>, true, true, TArgs_timetz_part_Policy>({}); }
 struct TArgs_timetz_pl_interval_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timetz_pl_interval() { return &GenericExec<TPgDirectFunc<&timetz_pl_interval>, true, false, TArgs_timetz_pl_interval_Policy>; }
+TExecFunc arrow_timetz_pl_interval() { return TGenericExec<TPgDirectFunc<&timetz_pl_interval>, true, false, TArgs_timetz_pl_interval_Policy>({}); }
 struct TArgs_timetz_recv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_timetz_recv() { return &GenericExec<TPgDirectFunc<&timetz_recv>, true, false, TArgs_timetz_recv_Policy>; }
+TExecFunc arrow_timetz_recv() { return TGenericExec<TPgDirectFunc<&timetz_recv>, true, false, TArgs_timetz_recv_Policy>({}); }
 struct TArgs_timetz_scale_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_timetz_scale() { return &GenericExec<TPgDirectFunc<&timetz_scale>, true, false, TArgs_timetz_scale_Policy>; }
+TExecFunc arrow_timetz_scale() { return TGenericExec<TPgDirectFunc<&timetz_scale>, true, false, TArgs_timetz_scale_Policy>({}); }
 struct TArgs_timetz_send_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_timetz_send() { return &GenericExec<TPgDirectFunc<&timetz_send>, true, false, TArgs_timetz_send_Policy>; }
+TExecFunc arrow_timetz_send() { return TGenericExec<TPgDirectFunc<&timetz_send>, true, false, TArgs_timetz_send_Policy>({}); }
 struct TArgs_timetz_smaller_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timetz_smaller() { return &GenericExec<TPgDirectFunc<&timetz_smaller>, true, false, TArgs_timetz_smaller_Policy>; }
+TExecFunc arrow_timetz_smaller() { return TGenericExec<TPgDirectFunc<&timetz_smaller>, true, false, TArgs_timetz_smaller_Policy>({}); }
 struct TArgs_timetz_time_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_timetz_time() { return &GenericExec<TPgDirectFunc<&timetz_time>, true, true, TArgs_timetz_time_Policy>; }
+TExecFunc arrow_timetz_time() { return TGenericExec<TPgDirectFunc<&timetz_time>, true, true, TArgs_timetz_time_Policy>({}); }
 struct TArgs_timetz_zone_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_timetz_zone() { return &GenericExec<TPgDirectFunc<&timetz_zone>, true, false, TArgs_timetz_zone_Policy>; }
+TExecFunc arrow_timetz_zone() { return TGenericExec<TPgDirectFunc<&timetz_zone>, true, false, TArgs_timetz_zone_Policy>({}); }
 struct TArgs_timetztypmodin_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_timetztypmodin() { return &GenericExec<TPgDirectFunc<&timetztypmodin>, true, true, TArgs_timetztypmodin_Policy>; }
+TExecFunc arrow_timetztypmodin() { return TGenericExec<TPgDirectFunc<&timetztypmodin>, true, true, TArgs_timetztypmodin_Policy>({}); }
 struct TArgs_timetztypmodout_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_timetztypmodout() { return &GenericExec<TPgDirectFunc<&timetztypmodout>, true, false, TArgs_timetztypmodout_Policy>; }
+TExecFunc arrow_timetztypmodout() { return TGenericExec<TPgDirectFunc<&timetztypmodout>, true, false, TArgs_timetztypmodout_Policy>({}); }
+struct TArgs_to_hex32_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_to_hex32() { return TGenericExec<TPgDirectFunc<&to_hex32>, true, false, TArgs_to_hex32_Policy>({}); }
+struct TArgs_to_hex64_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_to_hex64() { return TGenericExec<TPgDirectFunc<&to_hex64>, true, false, TArgs_to_hex64_Policy>({}); }
+struct TArgs_to_tsquery_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_to_tsquery() { return TGenericExec<TPgDirectFunc<&to_tsquery>, true, false, TArgs_to_tsquery_Policy>({}); }
+struct TArgs_to_tsquery_byid_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+};
+TExecFunc arrow_to_tsquery_byid() { return TGenericExec<TPgDirectFunc<&to_tsquery_byid>, true, false, TArgs_to_tsquery_byid_Policy>({}); }
+struct TArgs_to_tsvector_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_to_tsvector() { return TGenericExec<TPgDirectFunc<&to_tsvector>, true, false, TArgs_to_tsvector_Policy>({}); }
+struct TArgs_to_tsvector_byid_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+};
+TExecFunc arrow_to_tsvector_byid() { return TGenericExec<TPgDirectFunc<&to_tsvector_byid>, true, false, TArgs_to_tsvector_byid_Policy>({}); }
+struct TArgs_trim_array_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+};
+TExecFunc arrow_trim_array() { return TGenericExec<TPgDirectFunc<&trim_array>, true, false, TArgs_trim_array_Policy>({}); }
 struct TArgs_ts_headline_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_ts_headline() { return &GenericExec<TPgDirectFunc<&ts_headline>, true, false, TArgs_ts_headline_Policy>; }
+TExecFunc arrow_ts_headline() { return TGenericExec<TPgDirectFunc<&ts_headline>, true, false, TArgs_ts_headline_Policy>({}); }
 struct TArgs_ts_headline_byid_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
 };
-TExecFunc arrow_ts_headline_byid() { return &GenericExec<TPgDirectFunc<&ts_headline_byid>, true, false, TArgs_ts_headline_byid_Policy>; }
+TExecFunc arrow_ts_headline_byid() { return TGenericExec<TPgDirectFunc<&ts_headline_byid>, true, false, TArgs_ts_headline_byid_Policy>({}); }
 struct TArgs_ts_headline_byid_opt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 4> IsFixedArg = {true,false,false,false};
 };
-TExecFunc arrow_ts_headline_byid_opt() { return &GenericExec<TPgDirectFunc<&ts_headline_byid_opt>, true, false, TArgs_ts_headline_byid_opt_Policy>; }
+TExecFunc arrow_ts_headline_byid_opt() { return TGenericExec<TPgDirectFunc<&ts_headline_byid_opt>, true, false, TArgs_ts_headline_byid_opt_Policy>({}); }
 struct TArgs_ts_headline_json_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_ts_headline_json() { return &GenericExec<TPgDirectFunc<&ts_headline_json>, true, false, TArgs_ts_headline_json_Policy>; }
+TExecFunc arrow_ts_headline_json() { return TGenericExec<TPgDirectFunc<&ts_headline_json>, true, false, TArgs_ts_headline_json_Policy>({}); }
 struct TArgs_ts_headline_json_byid_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
 };
-TExecFunc arrow_ts_headline_json_byid() { return &GenericExec<TPgDirectFunc<&ts_headline_json_byid>, true, false, TArgs_ts_headline_json_byid_Policy>; }
+TExecFunc arrow_ts_headline_json_byid() { return TGenericExec<TPgDirectFunc<&ts_headline_json_byid>, true, false, TArgs_ts_headline_json_byid_Policy>({}); }
 struct TArgs_ts_headline_json_byid_opt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 4> IsFixedArg = {true,false,false,false};
 };
-TExecFunc arrow_ts_headline_json_byid_opt() { return &GenericExec<TPgDirectFunc<&ts_headline_json_byid_opt>, true, false, TArgs_ts_headline_json_byid_opt_Policy>; }
+TExecFunc arrow_ts_headline_json_byid_opt() { return TGenericExec<TPgDirectFunc<&ts_headline_json_byid_opt>, true, false, TArgs_ts_headline_json_byid_opt_Policy>({}); }
 struct TArgs_ts_headline_json_opt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
 };
-TExecFunc arrow_ts_headline_json_opt() { return &GenericExec<TPgDirectFunc<&ts_headline_json_opt>, true, false, TArgs_ts_headline_json_opt_Policy>; }
+TExecFunc arrow_ts_headline_json_opt() { return TGenericExec<TPgDirectFunc<&ts_headline_json_opt>, true, false, TArgs_ts_headline_json_opt_Policy>({}); }
 struct TArgs_ts_headline_jsonb_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_ts_headline_jsonb() { return &GenericExec<TPgDirectFunc<&ts_headline_jsonb>, true, false, TArgs_ts_headline_jsonb_Policy>; }
+TExecFunc arrow_ts_headline_jsonb() { return TGenericExec<TPgDirectFunc<&ts_headline_jsonb>, true, false, TArgs_ts_headline_jsonb_Policy>({}); }
 struct TArgs_ts_headline_jsonb_byid_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
 };
-TExecFunc arrow_ts_headline_jsonb_byid() { return &GenericExec<TPgDirectFunc<&ts_headline_jsonb_byid>, true, false, TArgs_ts_headline_jsonb_byid_Policy>; }
+TExecFunc arrow_ts_headline_jsonb_byid() { return TGenericExec<TPgDirectFunc<&ts_headline_jsonb_byid>, true, false, TArgs_ts_headline_jsonb_byid_Policy>({}); }
 struct TArgs_ts_headline_jsonb_byid_opt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 4> IsFixedArg = {true,false,false,false};
 };
-TExecFunc arrow_ts_headline_jsonb_byid_opt() { return &GenericExec<TPgDirectFunc<&ts_headline_jsonb_byid_opt>, true, false, TArgs_ts_headline_jsonb_byid_opt_Policy>; }
+TExecFunc arrow_ts_headline_jsonb_byid_opt() { return TGenericExec<TPgDirectFunc<&ts_headline_jsonb_byid_opt>, true, false, TArgs_ts_headline_jsonb_byid_opt_Policy>({}); }
 struct TArgs_ts_headline_jsonb_opt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
 };
-TExecFunc arrow_ts_headline_jsonb_opt() { return &GenericExec<TPgDirectFunc<&ts_headline_jsonb_opt>, true, false, TArgs_ts_headline_jsonb_opt_Policy>; }
+TExecFunc arrow_ts_headline_jsonb_opt() { return TGenericExec<TPgDirectFunc<&ts_headline_jsonb_opt>, true, false, TArgs_ts_headline_jsonb_opt_Policy>({}); }
 struct TArgs_ts_headline_opt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
 };
-TExecFunc arrow_ts_headline_opt() { return &GenericExec<TPgDirectFunc<&ts_headline_opt>, true, false, TArgs_ts_headline_opt_Policy>; }
-struct TArgs_tsquery_rewrite_Policy {
+TExecFunc arrow_ts_headline_opt() { return TGenericExec<TPgDirectFunc<&ts_headline_opt>, true, false, TArgs_ts_headline_opt_Policy>({}); }
+struct TArgs_ts_match_qv_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_ts_match_qv() { return TGenericExec<TPgDirectFunc<&ts_match_qv>, true, true, TArgs_ts_match_qv_Policy>({}); }
+struct TArgs_ts_match_tq_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_ts_match_tq() { return TGenericExec<TPgDirectFunc<&ts_match_tq>, true, true, TArgs_ts_match_tq_Policy>({}); }
+struct TArgs_ts_match_tt_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_ts_match_tt() { return TGenericExec<TPgDirectFunc<&ts_match_tt>, true, true, TArgs_ts_match_tt_Policy>({}); }
+struct TArgs_ts_match_vq_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_ts_match_vq() { return TGenericExec<TPgDirectFunc<&ts_match_vq>, true, true, TArgs_ts_match_vq_Policy>({}); }
+struct TArgs_ts_rank_tt_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_ts_rank_tt() { return TGenericExec<TPgDirectFunc<&ts_rank_tt>, true, true, TArgs_ts_rank_tt_Policy>({}); }
+struct TArgs_ts_rank_ttf_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,true};
+};
+TExecFunc arrow_ts_rank_ttf() { return TGenericExec<TPgDirectFunc<&ts_rank_ttf>, true, true, TArgs_ts_rank_ttf_Policy>({}); }
+struct TArgs_ts_rank_wtt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
 };
-TExecFunc arrow_tsquery_rewrite() { return &GenericExec<TPgDirectFunc<&tsquery_rewrite>, true, false, TArgs_tsquery_rewrite_Policy>; }
-struct TArgs_tsquery_rewrite_query_Policy {
+TExecFunc arrow_ts_rank_wtt() { return TGenericExec<TPgDirectFunc<&ts_rank_wtt>, true, true, TArgs_ts_rank_wtt_Policy>({}); }
+struct TArgs_ts_rank_wttf_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,true};
+};
+TExecFunc arrow_ts_rank_wttf() { return TGenericExec<TPgDirectFunc<&ts_rank_wttf>, true, true, TArgs_ts_rank_wttf_Policy>({}); }
+struct TArgs_ts_rankcd_tt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_tsquery_rewrite_query() { return &GenericExec<TPgDirectFunc<&tsquery_rewrite_query>, true, false, TArgs_tsquery_rewrite_query_Policy>; }
-struct TArgs_tsrange_subdiff_Policy {
+TExecFunc arrow_ts_rankcd_tt() { return TGenericExec<TPgDirectFunc<&ts_rankcd_tt>, true, true, TArgs_ts_rankcd_tt_Policy>({}); }
+struct TArgs_ts_rankcd_ttf_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,true};
 };
-TExecFunc arrow_tsrange_subdiff() { return &GenericExec<TPgDirectFunc<&tsrange_subdiff>, true, true, TArgs_tsrange_subdiff_Policy>; }
-struct TArgs_tstzrange_subdiff_Policy {
+TExecFunc arrow_ts_rankcd_ttf() { return TGenericExec<TPgDirectFunc<&ts_rankcd_ttf>, true, true, TArgs_ts_rankcd_ttf_Policy>({}); }
+struct TArgs_ts_rankcd_wtt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
 };
-TExecFunc arrow_tstzrange_subdiff() { return &GenericExec<TPgDirectFunc<&tstzrange_subdiff>, true, true, TArgs_tstzrange_subdiff_Policy>; }
-struct TArgs_xid8cmp_Policy {
+TExecFunc arrow_ts_rankcd_wtt() { return TGenericExec<TPgDirectFunc<&ts_rankcd_wtt>, true, true, TArgs_ts_rankcd_wtt_Policy>({}); }
+struct TArgs_ts_rankcd_wttf_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,true};
 };
-TExecFunc arrow_xid8cmp() { return &GenericExec<TPgDirectFunc<&xid8cmp>, true, true, TArgs_xid8cmp_Policy>; }
-struct TArgs_xid8eq_Policy {
+TExecFunc arrow_ts_rankcd_wttf() { return TGenericExec<TPgDirectFunc<&ts_rankcd_wttf>, true, true, TArgs_ts_rankcd_wttf_Policy>({}); }
+struct TArgs_tsvector_cmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_xid8eq() { return &GenericExec<TPgDirectFunc<&xid8eq>, true, true, TArgs_xid8eq_Policy>; }
-struct TArgs_xid8ge_Policy {
+TExecFunc arrow_tsvector_cmp() { return TGenericExec<TPgDirectFunc<&tsvector_cmp>, true, true, TArgs_tsvector_cmp_Policy>({}); }
+struct TArgs_tsvector_concat_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_xid8ge() { return &GenericExec<TPgDirectFunc<&xid8ge>, true, true, TArgs_xid8ge_Policy>; }
-struct TArgs_xid8gt_Policy {
+TExecFunc arrow_tsvector_concat() { return TGenericExec<TPgDirectFunc<&tsvector_concat>, true, false, TArgs_tsvector_concat_Policy>({}); }
+struct TArgs_tsvector_delete_arr_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_tsvector_delete_arr() { return TGenericExec<TPgDirectFunc<&tsvector_delete_arr>, true, false, TArgs_tsvector_delete_arr_Policy>({}); }
+struct TArgs_tsvector_delete_str_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_tsvector_delete_str() { return TGenericExec<TPgDirectFunc<&tsvector_delete_str>, true, false, TArgs_tsvector_delete_str_Policy>({}); }
+struct TArgs_tsvector_eq_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_tsvector_eq() { return TGenericExec<TPgDirectFunc<&tsvector_eq>, true, true, TArgs_tsvector_eq_Policy>({}); }
+struct TArgs_tsvector_filter_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_tsvector_filter() { return TGenericExec<TPgDirectFunc<&tsvector_filter>, true, false, TArgs_tsvector_filter_Policy>({}); }
+struct TArgs_tsvector_ge_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_tsvector_ge() { return TGenericExec<TPgDirectFunc<&tsvector_ge>, true, true, TArgs_tsvector_ge_Policy>({}); }
+struct TArgs_tsvector_gt_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_tsvector_gt() { return TGenericExec<TPgDirectFunc<&tsvector_gt>, true, true, TArgs_tsvector_gt_Policy>({}); }
+struct TArgs_tsvector_le_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_xid8gt() { return &GenericExec<TPgDirectFunc<&xid8gt>, true, true, TArgs_xid8gt_Policy>; }
-struct TArgs_xid8in_Policy {
+TExecFunc arrow_tsvector_le() { return TGenericExec<TPgDirectFunc<&tsvector_le>, true, true, TArgs_tsvector_le_Policy>({}); }
+struct TArgs_tsvector_length_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_xid8in() { return &GenericExec<TPgDirectFunc<&xid8in>, true, true, TArgs_xid8in_Policy>; }
-struct TArgs_xid8le_Policy {
+TExecFunc arrow_tsvector_length() { return TGenericExec<TPgDirectFunc<&tsvector_length>, true, true, TArgs_tsvector_length_Policy>({}); }
+struct TArgs_tsvector_lt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_xid8le() { return &GenericExec<TPgDirectFunc<&xid8le>, true, true, TArgs_xid8le_Policy>; }
-struct TArgs_xid8lt_Policy {
+TExecFunc arrow_tsvector_lt() { return TGenericExec<TPgDirectFunc<&tsvector_lt>, true, true, TArgs_tsvector_lt_Policy>({}); }
+struct TArgs_tsvector_ne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_xid8lt() { return &GenericExec<TPgDirectFunc<&xid8lt>, true, true, TArgs_xid8lt_Policy>; }
-struct TArgs_xid8ne_Policy {
+TExecFunc arrow_tsvector_ne() { return TGenericExec<TPgDirectFunc<&tsvector_ne>, true, true, TArgs_tsvector_ne_Policy>({}); }
+struct TArgs_tsvector_setweight_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_xid8ne() { return &GenericExec<TPgDirectFunc<&xid8ne>, true, true, TArgs_xid8ne_Policy>; }
-struct TArgs_xid8out_Policy {
+TExecFunc arrow_tsvector_setweight() { return TGenericExec<TPgDirectFunc<&tsvector_setweight>, true, false, TArgs_tsvector_setweight_Policy>({}); }
+struct TArgs_tsvector_setweight_by_filter_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
 };
-TExecFunc arrow_xid8out() { return &GenericExec<TPgDirectFunc<&xid8out>, true, false, TArgs_xid8out_Policy>; }
-struct TArgs_xid8recv_Policy {
+TExecFunc arrow_tsvector_setweight_by_filter() { return TGenericExec<TPgDirectFunc<&tsvector_setweight_by_filter>, true, false, TArgs_tsvector_setweight_by_filter_Policy>({}); }
+struct TArgs_tsvector_strip_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_xid8recv() { return &GenericExec<TPgDirectFunc<&xid8recv>, true, true, TArgs_xid8recv_Policy>; }
-struct TArgs_xid8send_Policy {
+TExecFunc arrow_tsvector_strip() { return TGenericExec<TPgDirectFunc<&tsvector_strip>, true, false, TArgs_tsvector_strip_Policy>({}); }
+struct TArgs_tsvector_to_array_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_xid8send() { return &GenericExec<TPgDirectFunc<&xid8send>, true, false, TArgs_xid8send_Policy>; }
-struct TArgs_xid8toxid_Policy {
+TExecFunc arrow_tsvector_to_array() { return TGenericExec<TPgDirectFunc<&tsvector_to_array>, true, false, TArgs_tsvector_to_array_Policy>({}); }
+struct TArgs_tsvector_update_trigger_bycolumn_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_xid8toxid() { return &GenericExec<TPgDirectFunc<&xid8toxid>, true, true, TArgs_xid8toxid_Policy>; }
-struct TArgs_xid_age_Policy {
+TExecFunc arrow_tsvector_update_trigger_bycolumn() { return TGenericExec<TPgDirectFunc<&tsvector_update_trigger_bycolumn>, false, true, TArgs_tsvector_update_trigger_bycolumn_Policy>({}); }
+struct TArgs_tsvector_update_trigger_byid_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_xid_age() { return &GenericExec<TPgDirectFunc<&xid_age>, true, true, TArgs_xid_age_Policy>; }
-struct TArgs_xideq_Policy {
+TExecFunc arrow_tsvector_update_trigger_byid() { return TGenericExec<TPgDirectFunc<&tsvector_update_trigger_byid>, false, true, TArgs_tsvector_update_trigger_byid_Policy>({}); }
+struct TArgs_unicode_is_normalized_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_unicode_is_normalized() { return TGenericExec<TPgDirectFunc<&unicode_is_normalized>, true, true, TArgs_unicode_is_normalized_Policy>({}); }
+struct TArgs_unicode_normalize_func_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_xideq() { return &GenericExec<TPgDirectFunc<&xideq>, true, true, TArgs_xideq_Policy>; }
-struct TArgs_xidin_Policy {
+TExecFunc arrow_unicode_normalize_func() { return TGenericExec<TPgDirectFunc<&unicode_normalize_func>, true, false, TArgs_unicode_normalize_func_Policy>({}); }
+struct TArgs_unique_key_recheck_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 0> IsFixedArg = {};
+};
+TExecFunc arrow_unique_key_recheck() { return TGenericExec<TPgDirectFunc<&unique_key_recheck>, true, true, TArgs_unique_key_recheck_Policy>({}); }
+struct TArgs_unistr_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_xidin() { return &GenericExec<TPgDirectFunc<&xidin>, true, true, TArgs_xidin_Policy>; }
-struct TArgs_xidneq_Policy {
+TExecFunc arrow_unistr() { return TGenericExec<TPgDirectFunc<&unistr>, true, false, TArgs_unistr_Policy>({}); }
+struct TArgs_unknownin_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_xidneq() { return &GenericExec<TPgDirectFunc<&xidneq>, true, true, TArgs_xidneq_Policy>; }
-struct TArgs_xidout_Policy {
+TExecFunc arrow_unknownin() { return TGenericExec<TPgDirectFunc<&unknownin>, true, false, TArgs_unknownin_Policy>({}); }
+struct TArgs_unknownout_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_xidout() { return &GenericExec<TPgDirectFunc<&xidout>, true, false, TArgs_xidout_Policy>; }
-struct TArgs_xidrecv_Policy {
+TExecFunc arrow_unknownout() { return TGenericExec<TPgDirectFunc<&unknownout>, true, false, TArgs_unknownout_Policy>({}); }
+struct TArgs_unknownrecv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_xidrecv() { return &GenericExec<TPgDirectFunc<&xidrecv>, true, true, TArgs_xidrecv_Policy>; }
-struct TArgs_xidsend_Policy {
+TExecFunc arrow_unknownrecv() { return TGenericExec<TPgDirectFunc<&unknownrecv>, true, false, TArgs_unknownrecv_Policy>({}); }
+struct TArgs_unknownsend_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_unknownsend() { return TGenericExec<TPgDirectFunc<&unknownsend>, true, false, TArgs_unknownsend_Policy>({}); }
+struct TArgs_websearch_to_tsquery_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_websearch_to_tsquery() { return TGenericExec<TPgDirectFunc<&websearch_to_tsquery>, true, false, TArgs_websearch_to_tsquery_Policy>({}); }
+struct TArgs_websearch_to_tsquery_byid_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+};
+TExecFunc arrow_websearch_to_tsquery_byid() { return TGenericExec<TPgDirectFunc<&websearch_to_tsquery_byid>, true, false, TArgs_websearch_to_tsquery_byid_Policy>({}); }
+struct TArgs_width_bucket_array_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+};
+TExecFunc arrow_width_bucket_array() { return TGenericExec<TPgDirectFunc<&width_bucket_array>, true, true, TArgs_width_bucket_array_Policy>({}); }
+struct TArgs_xml_in_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_xml_in() { return TGenericExec<TPgDirectFunc<&xml_in>, true, false, TArgs_xml_in_Policy>({}); }
+struct TArgs_xml_is_well_formed_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_xml_is_well_formed() { return TGenericExec<TPgDirectFunc<&xml_is_well_formed>, true, true, TArgs_xml_is_well_formed_Policy>({}); }
+struct TArgs_xml_is_well_formed_content_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_xml_is_well_formed_content() { return TGenericExec<TPgDirectFunc<&xml_is_well_formed_content>, true, true, TArgs_xml_is_well_formed_content_Policy>({}); }
+struct TArgs_xml_is_well_formed_document_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_xml_is_well_formed_document() { return TGenericExec<TPgDirectFunc<&xml_is_well_formed_document>, true, true, TArgs_xml_is_well_formed_document_Policy>({}); }
+struct TArgs_xml_out_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_xml_out() { return TGenericExec<TPgDirectFunc<&xml_out>, true, false, TArgs_xml_out_Policy>({}); }
+struct TArgs_xml_recv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_xidsend() { return &GenericExec<TPgDirectFunc<&xidsend>, true, false, TArgs_xidsend_Policy>; }
+TExecFunc arrow_xml_recv() { return TGenericExec<TPgDirectFunc<&xml_recv>, true, false, TArgs_xml_recv_Policy>({}); }
+struct TArgs_xml_send_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_xml_send() { return TGenericExec<TPgDirectFunc<&xml_send>, true, false, TArgs_xml_send_Policy>({}); }
+struct TArgs_xmlcomment_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_xmlcomment() { return TGenericExec<TPgDirectFunc<&xmlcomment>, true, false, TArgs_xmlcomment_Policy>({}); }
+struct TArgs_xmlconcat2_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_xmlconcat2() { return TGenericExec<TPgDirectFunc<&xmlconcat2>, false, false, TArgs_xmlconcat2_Policy>({}); }
+struct TArgs_xmlexists_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_xmlexists() { return TGenericExec<TPgDirectFunc<&xmlexists>, true, true, TArgs_xmlexists_Policy>({}); }
+struct TArgs_xmltotext_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_xmltotext() { return TGenericExec<TPgDirectFunc<&xmltotext>, true, false, TArgs_xmltotext_Policy>({}); }
+struct TArgs_xmlvalidate_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_xmlvalidate() { return TGenericExec<TPgDirectFunc<&xmlvalidate>, true, true, TArgs_xmlvalidate_Policy>({}); }
+struct TArgs_xpath_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+};
+TExecFunc arrow_xpath() { return TGenericExec<TPgDirectFunc<&xpath>, true, false, TArgs_xpath_Policy>({}); }
+struct TArgs_xpath_exists_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+};
+TExecFunc arrow_xpath_exists() { return TGenericExec<TPgDirectFunc<&xpath_exists>, true, true, TArgs_xpath_exists_Policy>({}); }
diff --git a/ydb/library/yql/parser/pg_wrapper/pg_kernels.2.cpp b/ydb/library/yql/parser/pg_wrapper/pg_kernels.2.cpp
index fe4b6276f23..e73c8ba7eb3 100644
--- a/ydb/library/yql/parser/pg_wrapper/pg_kernels.2.cpp
+++ b/ydb/library/yql/parser/pg_wrapper/pg_kernels.2.cpp
@@ -28,7 +28,11 @@ namespace NYql {
 
 extern "C" {
 
+#ifdef USE_SLOW_PG_KERNELS
+#include "pg_kernels.slow.2.inc"
+#else
 #include "pg_kernels.2.inc"
+#endif
 
 }
 
diff --git a/ydb/library/yql/parser/pg_wrapper/pg_kernels.2.inc b/ydb/library/yql/parser/pg_wrapper/pg_kernels.2.inc
index aac8627455b..d822281e66d 100644
--- a/ydb/library/yql/parser/pg_wrapper/pg_kernels.2.inc
+++ b/ydb/library/yql/parser/pg_wrapper/pg_kernels.2.inc
@@ -1,3815 +1,3410 @@
-struct TArgs_PG_char_to_encoding_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_PG_char_to_encoding() { return &GenericExec<TPgDirectFunc<&PG_char_to_encoding>, true, true, TArgs_PG_char_to_encoding_Policy>; }
-struct TArgs_PG_encoding_to_char_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_PG_encoding_to_char() { return &GenericExec<TPgDirectFunc<&PG_encoding_to_char>, true, false, TArgs_PG_encoding_to_char_Policy>; }
 struct TArgs_RI_FKey_cascade_del_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_RI_FKey_cascade_del() { return &GenericExec<TPgDirectFunc<&RI_FKey_cascade_del>, true, true, TArgs_RI_FKey_cascade_del_Policy>; }
+TExecFunc arrow_RI_FKey_cascade_del() { return TGenericExec<TPgDirectFunc<&RI_FKey_cascade_del>, true, true, TArgs_RI_FKey_cascade_del_Policy>({}); }
 struct TArgs_RI_FKey_cascade_upd_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_RI_FKey_cascade_upd() { return &GenericExec<TPgDirectFunc<&RI_FKey_cascade_upd>, true, true, TArgs_RI_FKey_cascade_upd_Policy>; }
+TExecFunc arrow_RI_FKey_cascade_upd() { return TGenericExec<TPgDirectFunc<&RI_FKey_cascade_upd>, true, true, TArgs_RI_FKey_cascade_upd_Policy>({}); }
 struct TArgs_RI_FKey_check_ins_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_RI_FKey_check_ins() { return &GenericExec<TPgDirectFunc<&RI_FKey_check_ins>, true, true, TArgs_RI_FKey_check_ins_Policy>; }
+TExecFunc arrow_RI_FKey_check_ins() { return TGenericExec<TPgDirectFunc<&RI_FKey_check_ins>, true, true, TArgs_RI_FKey_check_ins_Policy>({}); }
 struct TArgs_RI_FKey_check_upd_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_RI_FKey_check_upd() { return &GenericExec<TPgDirectFunc<&RI_FKey_check_upd>, true, true, TArgs_RI_FKey_check_upd_Policy>; }
+TExecFunc arrow_RI_FKey_check_upd() { return TGenericExec<TPgDirectFunc<&RI_FKey_check_upd>, true, true, TArgs_RI_FKey_check_upd_Policy>({}); }
 struct TArgs_RI_FKey_noaction_del_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_RI_FKey_noaction_del() { return &GenericExec<TPgDirectFunc<&RI_FKey_noaction_del>, true, true, TArgs_RI_FKey_noaction_del_Policy>; }
+TExecFunc arrow_RI_FKey_noaction_del() { return TGenericExec<TPgDirectFunc<&RI_FKey_noaction_del>, true, true, TArgs_RI_FKey_noaction_del_Policy>({}); }
 struct TArgs_RI_FKey_noaction_upd_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_RI_FKey_noaction_upd() { return &GenericExec<TPgDirectFunc<&RI_FKey_noaction_upd>, true, true, TArgs_RI_FKey_noaction_upd_Policy>; }
+TExecFunc arrow_RI_FKey_noaction_upd() { return TGenericExec<TPgDirectFunc<&RI_FKey_noaction_upd>, true, true, TArgs_RI_FKey_noaction_upd_Policy>({}); }
 struct TArgs_RI_FKey_restrict_del_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_RI_FKey_restrict_del() { return &GenericExec<TPgDirectFunc<&RI_FKey_restrict_del>, true, true, TArgs_RI_FKey_restrict_del_Policy>; }
+TExecFunc arrow_RI_FKey_restrict_del() { return TGenericExec<TPgDirectFunc<&RI_FKey_restrict_del>, true, true, TArgs_RI_FKey_restrict_del_Policy>({}); }
 struct TArgs_RI_FKey_restrict_upd_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_RI_FKey_restrict_upd() { return &GenericExec<TPgDirectFunc<&RI_FKey_restrict_upd>, true, true, TArgs_RI_FKey_restrict_upd_Policy>; }
+TExecFunc arrow_RI_FKey_restrict_upd() { return TGenericExec<TPgDirectFunc<&RI_FKey_restrict_upd>, true, true, TArgs_RI_FKey_restrict_upd_Policy>({}); }
 struct TArgs_RI_FKey_setdefault_del_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_RI_FKey_setdefault_del() { return &GenericExec<TPgDirectFunc<&RI_FKey_setdefault_del>, true, true, TArgs_RI_FKey_setdefault_del_Policy>; }
+TExecFunc arrow_RI_FKey_setdefault_del() { return TGenericExec<TPgDirectFunc<&RI_FKey_setdefault_del>, true, true, TArgs_RI_FKey_setdefault_del_Policy>({}); }
 struct TArgs_RI_FKey_setdefault_upd_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_RI_FKey_setdefault_upd() { return &GenericExec<TPgDirectFunc<&RI_FKey_setdefault_upd>, true, true, TArgs_RI_FKey_setdefault_upd_Policy>; }
+TExecFunc arrow_RI_FKey_setdefault_upd() { return TGenericExec<TPgDirectFunc<&RI_FKey_setdefault_upd>, true, true, TArgs_RI_FKey_setdefault_upd_Policy>({}); }
 struct TArgs_RI_FKey_setnull_del_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_RI_FKey_setnull_del() { return &GenericExec<TPgDirectFunc<&RI_FKey_setnull_del>, true, true, TArgs_RI_FKey_setnull_del_Policy>; }
+TExecFunc arrow_RI_FKey_setnull_del() { return TGenericExec<TPgDirectFunc<&RI_FKey_setnull_del>, true, true, TArgs_RI_FKey_setnull_del_Policy>({}); }
 struct TArgs_RI_FKey_setnull_upd_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_RI_FKey_setnull_upd() { return &GenericExec<TPgDirectFunc<&RI_FKey_setnull_upd>, true, true, TArgs_RI_FKey_setnull_upd_Policy>; }
-struct TArgs_aclcontains_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_aclcontains() { return &GenericExec<TPgDirectFunc<&aclcontains>, true, true, TArgs_aclcontains_Policy>; }
-struct TArgs_acldefault_sql_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
-};
-TExecFunc arrow_acldefault_sql() { return &GenericExec<TPgDirectFunc<&acldefault_sql>, true, false, TArgs_acldefault_sql_Policy>; }
-struct TArgs_aclinsert_Policy {
+TExecFunc arrow_RI_FKey_setnull_upd() { return TGenericExec<TPgDirectFunc<&RI_FKey_setnull_upd>, true, true, TArgs_RI_FKey_setnull_upd_Policy>({}); }
+struct TArgs_any_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_aclinsert() { return &GenericExec<TPgDirectFunc<&aclinsert>, true, false, TArgs_aclinsert_Policy>; }
-struct TArgs_aclitem_eq_Policy {
+TExecFunc arrow_any_in() { return TGenericExec<TPgDirectFunc<&any_in>, true, true, TArgs_any_in_Policy>({}); }
+struct TArgs_any_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_aclitem_eq() { return &GenericExec<TPgDirectFunc<&aclitem_eq>, true, true, TArgs_aclitem_eq_Policy>; }
-struct TArgs_aclitemin_Policy {
+TExecFunc arrow_any_out() { return TGenericExec<TPgDirectFunc<&any_out>, true, false, TArgs_any_out_Policy>({}); }
+struct TArgs_anyarray_in_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_aclitemin() { return &GenericExec<TPgDirectFunc<&aclitemin>, true, false, TArgs_aclitemin_Policy>; }
-struct TArgs_aclitemout_Policy {
+TExecFunc arrow_anyarray_in() { return TGenericExec<TPgDirectFunc<&anyarray_in>, true, false, TArgs_anyarray_in_Policy>({}); }
+struct TArgs_anyarray_out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_aclitemout() { return &GenericExec<TPgDirectFunc<&aclitemout>, true, false, TArgs_aclitemout_Policy>; }
-struct TArgs_aclremove_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_aclremove() { return &GenericExec<TPgDirectFunc<&aclremove>, true, false, TArgs_aclremove_Policy>; }
-struct TArgs_array_agg_array_finalfn_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
-};
-TExecFunc arrow_array_agg_array_finalfn() { return &GenericExec<TPgDirectFunc<&array_agg_array_finalfn>, false, false, TArgs_array_agg_array_finalfn_Policy>; }
-struct TArgs_array_agg_array_transfn_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
-};
-TExecFunc arrow_array_agg_array_transfn() { return &GenericExec<TPgDirectFunc<&array_agg_array_transfn>, false, true, TArgs_array_agg_array_transfn_Policy>; }
-struct TArgs_array_agg_finalfn_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
-};
-TExecFunc arrow_array_agg_finalfn() { return &GenericExec<TPgDirectFunc<&array_agg_finalfn>, false, false, TArgs_array_agg_finalfn_Policy>; }
-struct TArgs_array_agg_transfn_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
-};
-TExecFunc arrow_array_agg_transfn() { return &GenericExec<TPgDirectFunc<&array_agg_transfn>, false, true, TArgs_array_agg_transfn_Policy>; }
-struct TArgs_array_append_Policy {
+TExecFunc arrow_anyarray_out() { return TGenericExec<TPgDirectFunc<&anyarray_out>, true, false, TArgs_anyarray_out_Policy>({}); }
+struct TArgs_anyarray_recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_array_append() { return &GenericExec<TPgDirectFunc<&array_append>, false, false, TArgs_array_append_Policy>; }
-struct TArgs_array_cardinality_Policy {
+TExecFunc arrow_anyarray_recv() { return TGenericExec<TPgDirectFunc<&anyarray_recv>, true, false, TArgs_anyarray_recv_Policy>({}); }
+struct TArgs_anyarray_send_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_array_cardinality() { return &GenericExec<TPgDirectFunc<&array_cardinality>, true, true, TArgs_array_cardinality_Policy>; }
-struct TArgs_array_cat_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_array_cat() { return &GenericExec<TPgDirectFunc<&array_cat>, false, false, TArgs_array_cat_Policy>; }
-struct TArgs_array_dims_Policy {
+TExecFunc arrow_anyarray_send() { return TGenericExec<TPgDirectFunc<&anyarray_send>, true, false, TArgs_anyarray_send_Policy>({}); }
+struct TArgs_anycompatible_in_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_array_dims() { return &GenericExec<TPgDirectFunc<&array_dims>, true, false, TArgs_array_dims_Policy>; }
-struct TArgs_array_eq_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_array_eq() { return &GenericExec<TPgDirectFunc<&array_eq>, true, true, TArgs_array_eq_Policy>; }
-struct TArgs_array_fill_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
-};
-TExecFunc arrow_array_fill() { return &GenericExec<TPgDirectFunc<&array_fill>, false, false, TArgs_array_fill_Policy>; }
-struct TArgs_array_fill_with_lower_bounds_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
-};
-TExecFunc arrow_array_fill_with_lower_bounds() { return &GenericExec<TPgDirectFunc<&array_fill_with_lower_bounds>, false, false, TArgs_array_fill_with_lower_bounds_Policy>; }
-struct TArgs_array_ge_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_array_ge() { return &GenericExec<TPgDirectFunc<&array_ge>, true, true, TArgs_array_ge_Policy>; }
-struct TArgs_array_gt_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_array_gt() { return &GenericExec<TPgDirectFunc<&array_gt>, true, true, TArgs_array_gt_Policy>; }
-struct TArgs_array_in_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
-};
-TExecFunc arrow_array_in() { return &GenericExec<TPgDirectFunc<&array_in>, true, false, TArgs_array_in_Policy>; }
-struct TArgs_array_larger_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_array_larger() { return &GenericExec<TPgDirectFunc<&array_larger>, true, false, TArgs_array_larger_Policy>; }
-struct TArgs_array_le_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_array_le() { return &GenericExec<TPgDirectFunc<&array_le>, true, true, TArgs_array_le_Policy>; }
-struct TArgs_array_length_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
-};
-TExecFunc arrow_array_length() { return &GenericExec<TPgDirectFunc<&array_length>, true, true, TArgs_array_length_Policy>; }
-struct TArgs_array_lower_Policy {
+TExecFunc arrow_anycompatible_in() { return TGenericExec<TPgDirectFunc<&anycompatible_in>, true, true, TArgs_anycompatible_in_Policy>({}); }
+struct TArgs_anycompatible_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_array_lower() { return &GenericExec<TPgDirectFunc<&array_lower>, true, true, TArgs_array_lower_Policy>; }
-struct TArgs_array_lt_Policy {
+TExecFunc arrow_anycompatible_out() { return TGenericExec<TPgDirectFunc<&anycompatible_out>, true, false, TArgs_anycompatible_out_Policy>({}); }
+struct TArgs_anycompatiblearray_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_array_lt() { return &GenericExec<TPgDirectFunc<&array_lt>, true, true, TArgs_array_lt_Policy>; }
-struct TArgs_array_ndims_Policy {
+TExecFunc arrow_anycompatiblearray_in() { return TGenericExec<TPgDirectFunc<&anycompatiblearray_in>, true, false, TArgs_anycompatiblearray_in_Policy>({}); }
+struct TArgs_anycompatiblearray_out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_array_ndims() { return &GenericExec<TPgDirectFunc<&array_ndims>, true, true, TArgs_array_ndims_Policy>; }
-struct TArgs_array_ne_Policy {
+TExecFunc arrow_anycompatiblearray_out() { return TGenericExec<TPgDirectFunc<&anycompatiblearray_out>, true, false, TArgs_anycompatiblearray_out_Policy>({}); }
+struct TArgs_anycompatiblearray_recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_array_ne() { return &GenericExec<TPgDirectFunc<&array_ne>, true, true, TArgs_array_ne_Policy>; }
-struct TArgs_array_out_Policy {
+TExecFunc arrow_anycompatiblearray_recv() { return TGenericExec<TPgDirectFunc<&anycompatiblearray_recv>, true, false, TArgs_anycompatiblearray_recv_Policy>({}); }
+struct TArgs_anycompatiblearray_send_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_array_out() { return &GenericExec<TPgDirectFunc<&array_out>, true, false, TArgs_array_out_Policy>; }
-struct TArgs_array_position_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
-};
-TExecFunc arrow_array_position() { return &GenericExec<TPgDirectFunc<&array_position>, false, true, TArgs_array_position_Policy>; }
-struct TArgs_array_position_start_Policy {
+TExecFunc arrow_anycompatiblearray_send() { return TGenericExec<TPgDirectFunc<&anycompatiblearray_send>, true, false, TArgs_anycompatiblearray_send_Policy>({}); }
+struct TArgs_anycompatiblemultirange_in_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_array_position_start() { return &GenericExec<TPgDirectFunc<&array_position_start>, false, true, TArgs_array_position_start_Policy>; }
-struct TArgs_array_positions_Policy {
+TExecFunc arrow_anycompatiblemultirange_in() { return TGenericExec<TPgDirectFunc<&anycompatiblemultirange_in>, true, false, TArgs_anycompatiblemultirange_in_Policy>({}); }
+struct TArgs_anycompatiblemultirange_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
-};
-TExecFunc arrow_array_positions() { return &GenericExec<TPgDirectFunc<&array_positions>, false, false, TArgs_array_positions_Policy>; }
-struct TArgs_array_prepend_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_array_prepend() { return &GenericExec<TPgDirectFunc<&array_prepend>, false, false, TArgs_array_prepend_Policy>; }
-struct TArgs_array_recv_Policy {
+TExecFunc arrow_anycompatiblemultirange_out() { return TGenericExec<TPgDirectFunc<&anycompatiblemultirange_out>, true, false, TArgs_anycompatiblemultirange_out_Policy>({}); }
+struct TArgs_anycompatiblenonarray_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_array_recv() { return &GenericExec<TPgDirectFunc<&array_recv>, true, false, TArgs_array_recv_Policy>; }
-struct TArgs_array_remove_Policy {
+TExecFunc arrow_anycompatiblenonarray_in() { return TGenericExec<TPgDirectFunc<&anycompatiblenonarray_in>, true, true, TArgs_anycompatiblenonarray_in_Policy>({}); }
+struct TArgs_anycompatiblenonarray_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_array_remove() { return &GenericExec<TPgDirectFunc<&array_remove>, false, false, TArgs_array_remove_Policy>; }
-struct TArgs_array_replace_Policy {
+TExecFunc arrow_anycompatiblenonarray_out() { return TGenericExec<TPgDirectFunc<&anycompatiblenonarray_out>, true, false, TArgs_anycompatiblenonarray_out_Policy>({}); }
+struct TArgs_anycompatiblerange_in_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_array_replace() { return &GenericExec<TPgDirectFunc<&array_replace>, false, false, TArgs_array_replace_Policy>; }
-struct TArgs_array_send_Policy {
+TExecFunc arrow_anycompatiblerange_in() { return TGenericExec<TPgDirectFunc<&anycompatiblerange_in>, true, false, TArgs_anycompatiblerange_in_Policy>({}); }
+struct TArgs_anycompatiblerange_out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_array_send() { return &GenericExec<TPgDirectFunc<&array_send>, true, false, TArgs_array_send_Policy>; }
-struct TArgs_array_smaller_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_array_smaller() { return &GenericExec<TPgDirectFunc<&array_smaller>, true, false, TArgs_array_smaller_Policy>; }
-struct TArgs_array_to_json_Policy {
+TExecFunc arrow_anycompatiblerange_out() { return TGenericExec<TPgDirectFunc<&anycompatiblerange_out>, true, false, TArgs_anycompatiblerange_out_Policy>({}); }
+struct TArgs_anyelement_in_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_array_to_json() { return &GenericExec<TPgDirectFunc<&array_to_json>, true, false, TArgs_array_to_json_Policy>; }
-struct TArgs_array_to_json_pretty_Policy {
+TExecFunc arrow_anyelement_in() { return TGenericExec<TPgDirectFunc<&anyelement_in>, true, true, TArgs_anyelement_in_Policy>({}); }
+struct TArgs_anyelement_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_array_to_json_pretty() { return &GenericExec<TPgDirectFunc<&array_to_json_pretty>, true, false, TArgs_array_to_json_pretty_Policy>; }
-struct TArgs_array_to_tsvector_Policy {
+TExecFunc arrow_anyelement_out() { return TGenericExec<TPgDirectFunc<&anyelement_out>, true, false, TArgs_anyelement_out_Policy>({}); }
+struct TArgs_anyenum_in_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_array_to_tsvector() { return &GenericExec<TPgDirectFunc<&array_to_tsvector>, true, false, TArgs_array_to_tsvector_Policy>; }
-struct TArgs_array_unnest_support_Policy {
+TExecFunc arrow_anyenum_in() { return TGenericExec<TPgDirectFunc<&anyenum_in>, true, true, TArgs_anyenum_in_Policy>({}); }
+struct TArgs_anyenum_out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_array_unnest_support() { return &GenericExec<TPgDirectFunc<&array_unnest_support>, true, true, TArgs_array_unnest_support_Policy>; }
-struct TArgs_array_upper_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
-};
-TExecFunc arrow_array_upper() { return &GenericExec<TPgDirectFunc<&array_upper>, true, true, TArgs_array_upper_Policy>; }
-struct TArgs_arraycontained_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_arraycontained() { return &GenericExec<TPgDirectFunc<&arraycontained>, true, true, TArgs_arraycontained_Policy>; }
-struct TArgs_arraycontains_Policy {
+TExecFunc arrow_anyenum_out() { return TGenericExec<TPgDirectFunc<&anyenum_out>, true, false, TArgs_anyenum_out_Policy>({}); }
+struct TArgs_anymultirange_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_arraycontains() { return &GenericExec<TPgDirectFunc<&arraycontains>, true, true, TArgs_arraycontains_Policy>; }
-struct TArgs_arrayoverlap_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_arrayoverlap() { return &GenericExec<TPgDirectFunc<&arrayoverlap>, true, true, TArgs_arrayoverlap_Policy>; }
-struct TArgs_ascii_Policy {
+TExecFunc arrow_anymultirange_in() { return TGenericExec<TPgDirectFunc<&anymultirange_in>, true, false, TArgs_anymultirange_in_Policy>({}); }
+struct TArgs_anymultirange_out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_ascii() { return &GenericExec<TPgDirectFunc<&ascii>, true, true, TArgs_ascii_Policy>; }
-struct TArgs_binary_decode_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_binary_decode() { return &GenericExec<TPgDirectFunc<&binary_decode>, true, false, TArgs_binary_decode_Policy>; }
-struct TArgs_binary_encode_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_binary_encode() { return &GenericExec<TPgDirectFunc<&binary_encode>, true, false, TArgs_binary_encode_Policy>; }
-struct TArgs_box_above_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_box_above() { return &GenericExec<TPgDirectFunc<&box_above>, true, true, TArgs_box_above_Policy>; }
-struct TArgs_box_above_eq_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_box_above_eq() { return &GenericExec<TPgDirectFunc<&box_above_eq>, true, true, TArgs_box_above_eq_Policy>; }
-struct TArgs_box_add_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_box_add() { return &GenericExec<TPgDirectFunc<&box_add>, true, false, TArgs_box_add_Policy>; }
-struct TArgs_box_area_Policy {
+TExecFunc arrow_anymultirange_out() { return TGenericExec<TPgDirectFunc<&anymultirange_out>, true, false, TArgs_anymultirange_out_Policy>({}); }
+struct TArgs_anynonarray_in_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_box_area() { return &GenericExec<TPgDirectFunc<&box_area>, true, true, TArgs_box_area_Policy>; }
-struct TArgs_box_below_Policy {
+TExecFunc arrow_anynonarray_in() { return TGenericExec<TPgDirectFunc<&anynonarray_in>, true, true, TArgs_anynonarray_in_Policy>({}); }
+struct TArgs_anynonarray_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_box_below() { return &GenericExec<TPgDirectFunc<&box_below>, true, true, TArgs_box_below_Policy>; }
-struct TArgs_box_below_eq_Policy {
+TExecFunc arrow_anynonarray_out() { return TGenericExec<TPgDirectFunc<&anynonarray_out>, true, false, TArgs_anynonarray_out_Policy>({}); }
+struct TArgs_anyrange_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_box_below_eq() { return &GenericExec<TPgDirectFunc<&box_below_eq>, true, true, TArgs_box_below_eq_Policy>; }
-struct TArgs_box_center_Policy {
+TExecFunc arrow_anyrange_in() { return TGenericExec<TPgDirectFunc<&anyrange_in>, true, false, TArgs_anyrange_in_Policy>({}); }
+struct TArgs_anyrange_out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_box_center() { return &GenericExec<TPgDirectFunc<&box_center>, true, false, TArgs_box_center_Policy>; }
-struct TArgs_box_circle_Policy {
+TExecFunc arrow_anyrange_out() { return TGenericExec<TPgDirectFunc<&anyrange_out>, true, false, TArgs_anyrange_out_Policy>({}); }
+struct TArgs_arraycontjoinsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
 };
-TExecFunc arrow_box_circle() { return &GenericExec<TPgDirectFunc<&box_circle>, true, false, TArgs_box_circle_Policy>; }
-struct TArgs_box_contain_Policy {
+TExecFunc arrow_arraycontjoinsel() { return TGenericExec<TPgDirectFunc<&arraycontjoinsel>, true, true, TArgs_arraycontjoinsel_Policy>({}); }
+struct TArgs_arraycontsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_box_contain() { return &GenericExec<TPgDirectFunc<&box_contain>, true, true, TArgs_box_contain_Policy>; }
-struct TArgs_box_contain_pt_Policy {
+TExecFunc arrow_arraycontsel() { return TGenericExec<TPgDirectFunc<&arraycontsel>, true, true, TArgs_arraycontsel_Policy>({}); }
+struct TArgs_bpchar_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_box_contain_pt() { return &GenericExec<TPgDirectFunc<&box_contain_pt>, true, true, TArgs_box_contain_pt_Policy>; }
-struct TArgs_box_contained_Policy {
+TExecFunc arrow_bpchar() { return TGenericExec<TPgDirectFunc<&bpchar>, true, false, TArgs_bpchar_Policy>({}); }
+struct TArgs_bpchar_larger_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_box_contained() { return &GenericExec<TPgDirectFunc<&box_contained>, true, true, TArgs_box_contained_Policy>; }
-struct TArgs_box_diagonal_Policy {
+TExecFunc arrow_bpchar_larger() { return TGenericExec<TPgDirectFunc<&bpchar_larger>, true, false, TArgs_bpchar_larger_Policy>({}); }
+struct TArgs_bpchar_name_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_box_diagonal() { return &GenericExec<TPgDirectFunc<&box_diagonal>, true, false, TArgs_box_diagonal_Policy>; }
-struct TArgs_box_distance_Policy {
+TExecFunc arrow_bpchar_name() { return TGenericExec<TPgDirectFunc<&bpchar_name>, true, false, TArgs_bpchar_name_Policy>({}); }
+struct TArgs_bpchar_pattern_ge_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_box_distance() { return &GenericExec<TPgDirectFunc<&box_distance>, true, true, TArgs_box_distance_Policy>; }
-struct TArgs_box_div_Policy {
+TExecFunc arrow_bpchar_pattern_ge() { return TGenericExec<TPgDirectFunc<&bpchar_pattern_ge>, true, true, TArgs_bpchar_pattern_ge_Policy>({}); }
+struct TArgs_bpchar_pattern_gt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_box_div() { return &GenericExec<TPgDirectFunc<&box_div>, true, false, TArgs_box_div_Policy>; }
-struct TArgs_box_eq_Policy {
+TExecFunc arrow_bpchar_pattern_gt() { return TGenericExec<TPgDirectFunc<&bpchar_pattern_gt>, true, true, TArgs_bpchar_pattern_gt_Policy>({}); }
+struct TArgs_bpchar_pattern_le_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_box_eq() { return &GenericExec<TPgDirectFunc<&box_eq>, true, true, TArgs_box_eq_Policy>; }
-struct TArgs_box_ge_Policy {
+TExecFunc arrow_bpchar_pattern_le() { return TGenericExec<TPgDirectFunc<&bpchar_pattern_le>, true, true, TArgs_bpchar_pattern_le_Policy>({}); }
+struct TArgs_bpchar_pattern_lt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_box_ge() { return &GenericExec<TPgDirectFunc<&box_ge>, true, true, TArgs_box_ge_Policy>; }
-struct TArgs_box_gt_Policy {
+TExecFunc arrow_bpchar_pattern_lt() { return TGenericExec<TPgDirectFunc<&bpchar_pattern_lt>, true, true, TArgs_bpchar_pattern_lt_Policy>({}); }
+struct TArgs_bpchar_smaller_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_box_gt() { return &GenericExec<TPgDirectFunc<&box_gt>, true, true, TArgs_box_gt_Policy>; }
-struct TArgs_box_height_Policy {
+TExecFunc arrow_bpchar_smaller() { return TGenericExec<TPgDirectFunc<&bpchar_smaller>, true, false, TArgs_bpchar_smaller_Policy>({}); }
+struct TArgs_bpchar_sortsupport_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_box_height() { return &GenericExec<TPgDirectFunc<&box_height>, true, true, TArgs_box_height_Policy>; }
-struct TArgs_box_in_Policy {
+TExecFunc arrow_bpchar_sortsupport() { return TGenericExec<TPgDirectFunc<&bpchar_sortsupport>, true, true, TArgs_bpchar_sortsupport_Policy>({}); }
+struct TArgs_bpcharcmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_box_in() { return &GenericExec<TPgDirectFunc<&box_in>, true, false, TArgs_box_in_Policy>; }
-struct TArgs_box_intersect_Policy {
+TExecFunc arrow_bpcharcmp() { return TGenericExec<TPgDirectFunc<&bpcharcmp>, true, true, TArgs_bpcharcmp_Policy>({}); }
+struct TArgs_bpchareq_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_box_intersect() { return &GenericExec<TPgDirectFunc<&box_intersect>, true, false, TArgs_box_intersect_Policy>; }
-struct TArgs_box_le_Policy {
+TExecFunc arrow_bpchareq() { return TGenericExec<TPgDirectFunc<&bpchareq>, true, true, TArgs_bpchareq_Policy>({}); }
+struct TArgs_bpcharge_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_box_le() { return &GenericExec<TPgDirectFunc<&box_le>, true, true, TArgs_box_le_Policy>; }
-struct TArgs_box_left_Policy {
+TExecFunc arrow_bpcharge() { return TGenericExec<TPgDirectFunc<&bpcharge>, true, true, TArgs_bpcharge_Policy>({}); }
+struct TArgs_bpchargt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_box_left() { return &GenericExec<TPgDirectFunc<&box_left>, true, true, TArgs_box_left_Policy>; }
-struct TArgs_box_lt_Policy {
+TExecFunc arrow_bpchargt() { return TGenericExec<TPgDirectFunc<&bpchargt>, true, true, TArgs_bpchargt_Policy>({}); }
+struct TArgs_bpcharin_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_box_lt() { return &GenericExec<TPgDirectFunc<&box_lt>, true, true, TArgs_box_lt_Policy>; }
-struct TArgs_box_mul_Policy {
+TExecFunc arrow_bpcharin() { return TGenericExec<TPgDirectFunc<&bpcharin>, true, false, TArgs_bpcharin_Policy>({}); }
+struct TArgs_bpcharle_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_box_mul() { return &GenericExec<TPgDirectFunc<&box_mul>, true, false, TArgs_box_mul_Policy>; }
-struct TArgs_box_out_Policy {
+TExecFunc arrow_bpcharle() { return TGenericExec<TPgDirectFunc<&bpcharle>, true, true, TArgs_bpcharle_Policy>({}); }
+struct TArgs_bpcharlen_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_box_out() { return &GenericExec<TPgDirectFunc<&box_out>, true, false, TArgs_box_out_Policy>; }
-struct TArgs_box_overabove_Policy {
+TExecFunc arrow_bpcharlen() { return TGenericExec<TPgDirectFunc<&bpcharlen>, true, true, TArgs_bpcharlen_Policy>({}); }
+struct TArgs_bpcharlt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_box_overabove() { return &GenericExec<TPgDirectFunc<&box_overabove>, true, true, TArgs_box_overabove_Policy>; }
-struct TArgs_box_overbelow_Policy {
+TExecFunc arrow_bpcharlt() { return TGenericExec<TPgDirectFunc<&bpcharlt>, true, true, TArgs_bpcharlt_Policy>({}); }
+struct TArgs_bpcharne_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_box_overbelow() { return &GenericExec<TPgDirectFunc<&box_overbelow>, true, true, TArgs_box_overbelow_Policy>; }
-struct TArgs_box_overlap_Policy {
+TExecFunc arrow_bpcharne() { return TGenericExec<TPgDirectFunc<&bpcharne>, true, true, TArgs_bpcharne_Policy>({}); }
+struct TArgs_bpcharoctetlen_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_box_overlap() { return &GenericExec<TPgDirectFunc<&box_overlap>, true, true, TArgs_box_overlap_Policy>; }
-struct TArgs_box_overleft_Policy {
+TExecFunc arrow_bpcharoctetlen() { return TGenericExec<TPgDirectFunc<&bpcharoctetlen>, true, true, TArgs_bpcharoctetlen_Policy>({}); }
+struct TArgs_bpcharout_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_box_overleft() { return &GenericExec<TPgDirectFunc<&box_overleft>, true, true, TArgs_box_overleft_Policy>; }
-struct TArgs_box_overright_Policy {
+TExecFunc arrow_bpcharout() { return TGenericExec<TPgDirectFunc<&bpcharout>, true, false, TArgs_bpcharout_Policy>({}); }
+struct TArgs_bpcharrecv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_box_overright() { return &GenericExec<TPgDirectFunc<&box_overright>, true, true, TArgs_box_overright_Policy>; }
-struct TArgs_box_poly_Policy {
+TExecFunc arrow_bpcharrecv() { return TGenericExec<TPgDirectFunc<&bpcharrecv>, true, false, TArgs_bpcharrecv_Policy>({}); }
+struct TArgs_bpcharsend_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_box_poly() { return &GenericExec<TPgDirectFunc<&box_poly>, true, false, TArgs_box_poly_Policy>; }
-struct TArgs_box_recv_Policy {
+TExecFunc arrow_bpcharsend() { return TGenericExec<TPgDirectFunc<&bpcharsend>, true, false, TArgs_bpcharsend_Policy>({}); }
+struct TArgs_bpchartypmodin_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_box_recv() { return &GenericExec<TPgDirectFunc<&box_recv>, true, false, TArgs_box_recv_Policy>; }
-struct TArgs_box_right_Policy {
+TExecFunc arrow_bpchartypmodin() { return TGenericExec<TPgDirectFunc<&bpchartypmodin>, true, true, TArgs_bpchartypmodin_Policy>({}); }
+struct TArgs_bpchartypmodout_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_box_right() { return &GenericExec<TPgDirectFunc<&box_right>, true, true, TArgs_box_right_Policy>; }
-struct TArgs_box_same_Policy {
+TExecFunc arrow_bpchartypmodout() { return TGenericExec<TPgDirectFunc<&bpchartypmodout>, true, false, TArgs_bpchartypmodout_Policy>({}); }
+struct TArgs_brin_minmax_add_value_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_box_same() { return &GenericExec<TPgDirectFunc<&box_same>, true, true, TArgs_box_same_Policy>; }
-struct TArgs_box_send_Policy {
+TExecFunc arrow_brin_minmax_add_value() { return TGenericExec<TPgDirectFunc<&brin_minmax_add_value>, true, true, TArgs_brin_minmax_add_value_Policy>({}); }
+struct TArgs_brin_minmax_consistent_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_box_send() { return &GenericExec<TPgDirectFunc<&box_send>, true, false, TArgs_box_send_Policy>; }
-struct TArgs_box_sub_Policy {
+TExecFunc arrow_brin_minmax_consistent() { return TGenericExec<TPgDirectFunc<&brin_minmax_consistent>, true, true, TArgs_brin_minmax_consistent_Policy>({}); }
+struct TArgs_brin_minmax_opcinfo_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_box_sub() { return &GenericExec<TPgDirectFunc<&box_sub>, true, false, TArgs_box_sub_Policy>; }
-struct TArgs_box_width_Policy {
+TExecFunc arrow_brin_minmax_opcinfo() { return TGenericExec<TPgDirectFunc<&brin_minmax_opcinfo>, true, true, TArgs_brin_minmax_opcinfo_Policy>({}); }
+struct TArgs_brin_minmax_union_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_box_width() { return &GenericExec<TPgDirectFunc<&box_width>, true, true, TArgs_box_width_Policy>; }
-struct TArgs_boxes_bound_box_Policy {
+TExecFunc arrow_brin_minmax_union() { return TGenericExec<TPgDirectFunc<&brin_minmax_union>, true, true, TArgs_brin_minmax_union_Policy>({}); }
+struct TArgs_btbpchar_pattern_cmp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_boxes_bound_box() { return &GenericExec<TPgDirectFunc<&boxes_bound_box>, true, false, TArgs_boxes_bound_box_Policy>; }
-struct TArgs_bpchar_Policy {
+TExecFunc arrow_btbpchar_pattern_cmp() { return TGenericExec<TPgDirectFunc<&btbpchar_pattern_cmp>, true, true, TArgs_btbpchar_pattern_cmp_Policy>({}); }
+struct TArgs_btbpchar_pattern_sortsupport_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_bpchar() { return &GenericExec<TPgDirectFunc<&bpchar>, true, false, TArgs_bpchar_Policy>; }
-struct TArgs_bpchar_larger_Policy {
+TExecFunc arrow_btbpchar_pattern_sortsupport() { return TGenericExec<TPgDirectFunc<&btbpchar_pattern_sortsupport>, true, true, TArgs_btbpchar_pattern_sortsupport_Policy>({}); }
+struct TArgs_btfloat48cmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_bpchar_larger() { return &GenericExec<TPgDirectFunc<&bpchar_larger>, true, false, TArgs_bpchar_larger_Policy>; }
-struct TArgs_bpchar_name_Policy {
+TExecFunc arrow_btfloat48cmp() { return TGenericExec<TPgDirectFunc<&btfloat48cmp>, true, true, TArgs_btfloat48cmp_Policy>({}); }
+struct TArgs_btfloat4cmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_bpchar_name() { return &GenericExec<TPgDirectFunc<&bpchar_name>, true, false, TArgs_bpchar_name_Policy>; }
-struct TArgs_bpchar_pattern_ge_Policy {
+TExecFunc arrow_btfloat4cmp() { return TGenericExec<TPgDirectFunc<&btfloat4cmp>, true, true, TArgs_btfloat4cmp_Policy>({}); }
+struct TArgs_btfloat4sortsupport_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_bpchar_pattern_ge() { return &GenericExec<TPgDirectFunc<&bpchar_pattern_ge>, true, true, TArgs_bpchar_pattern_ge_Policy>; }
-struct TArgs_bpchar_pattern_gt_Policy {
+TExecFunc arrow_btfloat4sortsupport() { return TGenericExec<TPgDirectFunc<&btfloat4sortsupport>, true, true, TArgs_btfloat4sortsupport_Policy>({}); }
+struct TArgs_btfloat84cmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_bpchar_pattern_gt() { return &GenericExec<TPgDirectFunc<&bpchar_pattern_gt>, true, true, TArgs_bpchar_pattern_gt_Policy>; }
-struct TArgs_bpchar_pattern_le_Policy {
+TExecFunc arrow_btfloat84cmp() { return TGenericExec<TPgDirectFunc<&btfloat84cmp>, true, true, TArgs_btfloat84cmp_Policy>({}); }
+struct TArgs_btfloat8cmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_bpchar_pattern_le() { return &GenericExec<TPgDirectFunc<&bpchar_pattern_le>, true, true, TArgs_bpchar_pattern_le_Policy>; }
-struct TArgs_bpchar_pattern_lt_Policy {
+TExecFunc arrow_btfloat8cmp() { return TGenericExec<TPgDirectFunc<&btfloat8cmp>, true, true, TArgs_btfloat8cmp_Policy>({}); }
+struct TArgs_btfloat8sortsupport_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_bpchar_pattern_lt() { return &GenericExec<TPgDirectFunc<&bpchar_pattern_lt>, true, true, TArgs_bpchar_pattern_lt_Policy>; }
-struct TArgs_bpchar_smaller_Policy {
+TExecFunc arrow_btfloat8sortsupport() { return TGenericExec<TPgDirectFunc<&btfloat8sortsupport>, true, true, TArgs_btfloat8sortsupport_Policy>({}); }
+struct TArgs_btnamecmp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_bpchar_smaller() { return &GenericExec<TPgDirectFunc<&bpchar_smaller>, true, false, TArgs_bpchar_smaller_Policy>; }
-struct TArgs_bpchar_sortsupport_Policy {
+TExecFunc arrow_btnamecmp() { return TGenericExec<TPgDirectFunc<&btnamecmp>, true, true, TArgs_btnamecmp_Policy>({}); }
+struct TArgs_btnamesortsupport_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_bpchar_sortsupport() { return &GenericExec<TPgDirectFunc<&bpchar_sortsupport>, true, true, TArgs_bpchar_sortsupport_Policy>; }
-struct TArgs_bpcharcmp_Policy {
+TExecFunc arrow_btnamesortsupport() { return TGenericExec<TPgDirectFunc<&btnamesortsupport>, true, true, TArgs_btnamesortsupport_Policy>({}); }
+struct TArgs_btrecordcmp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_bpcharcmp() { return &GenericExec<TPgDirectFunc<&bpcharcmp>, true, true, TArgs_bpcharcmp_Policy>; }
-struct TArgs_bpchareq_Policy {
+TExecFunc arrow_btrecordcmp() { return TGenericExec<TPgDirectFunc<&btrecordcmp>, true, true, TArgs_btrecordcmp_Policy>({}); }
+struct TArgs_btrecordimagecmp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_bpchareq() { return &GenericExec<TPgDirectFunc<&bpchareq>, true, true, TArgs_bpchareq_Policy>; }
-struct TArgs_bpcharge_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_bpcharge() { return &GenericExec<TPgDirectFunc<&bpcharge>, true, true, TArgs_bpcharge_Policy>; }
-struct TArgs_bpchargt_Policy {
+TExecFunc arrow_btrecordimagecmp() { return TGenericExec<TPgDirectFunc<&btrecordimagecmp>, true, true, TArgs_btrecordimagecmp_Policy>({}); }
+struct TArgs_char_bpchar_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_bpchargt() { return &GenericExec<TPgDirectFunc<&bpchargt>, true, true, TArgs_bpchargt_Policy>; }
-struct TArgs_bpcharin_Policy {
+TExecFunc arrow_char_bpchar() { return TGenericExec<TPgDirectFunc<&char_bpchar>, true, false, TArgs_char_bpchar_Policy>({}); }
+struct TArgs_cideq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_bpcharin() { return &GenericExec<TPgDirectFunc<&bpcharin>, true, false, TArgs_bpcharin_Policy>; }
-struct TArgs_bpcharle_Policy {
+TExecFunc arrow_cideq() { return TGenericExec<TPgDirectFunc<&cideq>, true, true, TArgs_cideq_Policy>({}); }
+struct TArgs_cidin_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_bpcharle() { return &GenericExec<TPgDirectFunc<&bpcharle>, true, true, TArgs_bpcharle_Policy>; }
-struct TArgs_bpcharlen_Policy {
+TExecFunc arrow_cidin() { return TGenericExec<TPgDirectFunc<&cidin>, true, true, TArgs_cidin_Policy>({}); }
+struct TArgs_cidout_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_bpcharlen() { return &GenericExec<TPgDirectFunc<&bpcharlen>, true, true, TArgs_bpcharlen_Policy>; }
-struct TArgs_bpcharlt_Policy {
+TExecFunc arrow_cidout() { return TGenericExec<TPgDirectFunc<&cidout>, true, false, TArgs_cidout_Policy>({}); }
+struct TArgs_cidrecv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_bpcharlt() { return &GenericExec<TPgDirectFunc<&bpcharlt>, true, true, TArgs_bpcharlt_Policy>; }
-struct TArgs_bpcharne_Policy {
+TExecFunc arrow_cidrecv() { return TGenericExec<TPgDirectFunc<&cidrecv>, true, true, TArgs_cidrecv_Policy>({}); }
+struct TArgs_cidsend_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_bpcharne() { return &GenericExec<TPgDirectFunc<&bpcharne>, true, true, TArgs_bpcharne_Policy>; }
-struct TArgs_bpcharoctetlen_Policy {
+TExecFunc arrow_cidsend() { return TGenericExec<TPgDirectFunc<&cidsend>, true, false, TArgs_cidsend_Policy>({}); }
+struct TArgs_cstring_in_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_bpcharoctetlen() { return &GenericExec<TPgDirectFunc<&bpcharoctetlen>, true, true, TArgs_bpcharoctetlen_Policy>; }
-struct TArgs_bpcharout_Policy {
+TExecFunc arrow_cstring_in() { return TGenericExec<TPgDirectFunc<&cstring_in>, true, false, TArgs_cstring_in_Policy>({}); }
+struct TArgs_cstring_out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_bpcharout() { return &GenericExec<TPgDirectFunc<&bpcharout>, true, false, TArgs_bpcharout_Policy>; }
-struct TArgs_bpcharrecv_Policy {
+TExecFunc arrow_cstring_out() { return TGenericExec<TPgDirectFunc<&cstring_out>, true, false, TArgs_cstring_out_Policy>({}); }
+struct TArgs_cstring_recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_bpcharrecv() { return &GenericExec<TPgDirectFunc<&bpcharrecv>, true, false, TArgs_bpcharrecv_Policy>; }
-struct TArgs_bpcharsend_Policy {
+TExecFunc arrow_cstring_recv() { return TGenericExec<TPgDirectFunc<&cstring_recv>, true, false, TArgs_cstring_recv_Policy>({}); }
+struct TArgs_cstring_send_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_bpcharsend() { return &GenericExec<TPgDirectFunc<&bpcharsend>, true, false, TArgs_bpcharsend_Policy>; }
-struct TArgs_bpchartypmodin_Policy {
+TExecFunc arrow_cstring_send() { return TGenericExec<TPgDirectFunc<&cstring_send>, true, false, TArgs_cstring_send_Policy>({}); }
+struct TArgs_current_schema_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_bpchartypmodin() { return &GenericExec<TPgDirectFunc<&bpchartypmodin>, true, true, TArgs_bpchartypmodin_Policy>; }
-struct TArgs_bpchartypmodout_Policy {
+TExecFunc arrow_current_schema() { return TGenericExec<TPgDirectFunc<&current_schema>, true, false, TArgs_current_schema_Policy>({}); }
+struct TArgs_current_schemas_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_bpchartypmodout() { return &GenericExec<TPgDirectFunc<&bpchartypmodout>, true, false, TArgs_bpchartypmodout_Policy>; }
-struct TArgs_brin_desummarize_range_Policy {
+TExecFunc arrow_current_schemas() { return TGenericExec<TPgDirectFunc<&current_schemas>, true, false, TArgs_current_schemas_Policy>({}); }
+struct TArgs_current_user_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_brin_desummarize_range() { return &GenericExec<TPgDirectFunc<&brin_desummarize_range>, true, true, TArgs_brin_desummarize_range_Policy>; }
-struct TArgs_brin_summarize_new_values_Policy {
+TExecFunc arrow_current_user() { return TGenericExec<TPgDirectFunc<&current_user>, true, false, TArgs_current_user_Policy>({}); }
+struct TArgs_currval_oid_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_brin_summarize_new_values() { return &GenericExec<TPgDirectFunc<&brin_summarize_new_values>, true, true, TArgs_brin_summarize_new_values_Policy>; }
-struct TArgs_brin_summarize_range_Policy {
+TExecFunc arrow_currval_oid() { return TGenericExec<TPgDirectFunc<&currval_oid>, true, true, TArgs_currval_oid_Policy>({}); }
+struct TArgs_dacos_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_brin_summarize_range() { return &GenericExec<TPgDirectFunc<&brin_summarize_range>, true, true, TArgs_brin_summarize_range_Policy>; }
-struct TArgs_brinhandler_Policy {
+TExecFunc arrow_dacos() { return TGenericExec<TPgDirectFunc<&dacos>, true, true, TArgs_dacos_Policy>({}); }
+struct TArgs_dacosd_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_brinhandler() { return &GenericExec<TPgDirectFunc<&brinhandler>, true, true, TArgs_brinhandler_Policy>; }
-struct TArgs_btarraycmp_Policy {
+TExecFunc arrow_dacosd() { return TGenericExec<TPgDirectFunc<&dacosd>, true, true, TArgs_dacosd_Policy>({}); }
+struct TArgs_dacosh_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_btarraycmp() { return &GenericExec<TPgDirectFunc<&btarraycmp>, true, true, TArgs_btarraycmp_Policy>; }
-struct TArgs_btboolcmp_Policy {
+TExecFunc arrow_dacosh() { return TGenericExec<TPgDirectFunc<&dacosh>, true, true, TArgs_dacosh_Policy>({}); }
+struct TArgs_dasin_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_btboolcmp() { return &GenericExec<TPgDirectFunc<&btboolcmp>, true, true, TArgs_btboolcmp_Policy>; }
-struct TArgs_btbpchar_pattern_cmp_Policy {
+TExecFunc arrow_dasin() { return TGenericExec<TPgDirectFunc<&dasin>, true, true, TArgs_dasin_Policy>({}); }
+struct TArgs_dasind_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_btbpchar_pattern_cmp() { return &GenericExec<TPgDirectFunc<&btbpchar_pattern_cmp>, true, true, TArgs_btbpchar_pattern_cmp_Policy>; }
-struct TArgs_btbpchar_pattern_sortsupport_Policy {
+TExecFunc arrow_dasind() { return TGenericExec<TPgDirectFunc<&dasind>, true, true, TArgs_dasind_Policy>({}); }
+struct TArgs_dasinh_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_btbpchar_pattern_sortsupport() { return &GenericExec<TPgDirectFunc<&btbpchar_pattern_sortsupport>, true, true, TArgs_btbpchar_pattern_sortsupport_Policy>; }
-struct TArgs_btcharcmp_Policy {
+TExecFunc arrow_dasinh() { return TGenericExec<TPgDirectFunc<&dasinh>, true, true, TArgs_dasinh_Policy>({}); }
+struct TArgs_datan_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_btcharcmp() { return &GenericExec<TPgDirectFunc<&btcharcmp>, true, true, TArgs_btcharcmp_Policy>; }
-struct TArgs_btint24cmp_Policy {
+TExecFunc arrow_datan() { return TGenericExec<TPgDirectFunc<&datan>, true, true, TArgs_datan_Policy>({}); }
+struct TArgs_datan2_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_btint24cmp() { return &GenericExec<TPgDirectFunc<&btint24cmp>, true, true, TArgs_btint24cmp_Policy>; }
-struct TArgs_btint28cmp_Policy {
+TExecFunc arrow_datan2() { return TGenericExec<TPgDirectFunc<&datan2>, true, true, TArgs_datan2_Policy>({}); }
+struct TArgs_datan2d_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_btint28cmp() { return &GenericExec<TPgDirectFunc<&btint28cmp>, true, true, TArgs_btint28cmp_Policy>; }
-struct TArgs_btint2cmp_Policy {
+TExecFunc arrow_datan2d() { return TGenericExec<TPgDirectFunc<&datan2d>, true, true, TArgs_datan2d_Policy>({}); }
+struct TArgs_datand_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_btint2cmp() { return &GenericExec<TPgDirectFunc<&btint2cmp>, true, true, TArgs_btint2cmp_Policy>; }
-struct TArgs_btint2sortsupport_Policy {
+TExecFunc arrow_datand() { return TGenericExec<TPgDirectFunc<&datand>, true, true, TArgs_datand_Policy>({}); }
+struct TArgs_datanh_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_btint2sortsupport() { return &GenericExec<TPgDirectFunc<&btint2sortsupport>, true, true, TArgs_btint2sortsupport_Policy>; }
-struct TArgs_btint42cmp_Policy {
+TExecFunc arrow_datanh() { return TGenericExec<TPgDirectFunc<&datanh>, true, true, TArgs_datanh_Policy>({}); }
+struct TArgs_dcbrt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_btint42cmp() { return &GenericExec<TPgDirectFunc<&btint42cmp>, true, true, TArgs_btint42cmp_Policy>; }
-struct TArgs_btint48cmp_Policy {
+TExecFunc arrow_dcbrt() { return TGenericExec<TPgDirectFunc<&dcbrt>, true, true, TArgs_dcbrt_Policy>({}); }
+struct TArgs_dceil_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_btint48cmp() { return &GenericExec<TPgDirectFunc<&btint48cmp>, true, true, TArgs_btint48cmp_Policy>; }
-struct TArgs_btint4cmp_Policy {
+TExecFunc arrow_dceil() { return TGenericExec<TPgDirectFunc<&dceil>, true, true, TArgs_dceil_Policy>({}); }
+struct TArgs_dcos_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_btint4cmp() { return &GenericExec<TPgDirectFunc<&btint4cmp>, true, true, TArgs_btint4cmp_Policy>; }
-struct TArgs_btint4sortsupport_Policy {
+TExecFunc arrow_dcos() { return TGenericExec<TPgDirectFunc<&dcos>, true, true, TArgs_dcos_Policy>({}); }
+struct TArgs_dcosd_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_btint4sortsupport() { return &GenericExec<TPgDirectFunc<&btint4sortsupport>, true, true, TArgs_btint4sortsupport_Policy>; }
-struct TArgs_btint82cmp_Policy {
+TExecFunc arrow_dcosd() { return TGenericExec<TPgDirectFunc<&dcosd>, true, true, TArgs_dcosd_Policy>({}); }
+struct TArgs_dcosh_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_btint82cmp() { return &GenericExec<TPgDirectFunc<&btint82cmp>, true, true, TArgs_btint82cmp_Policy>; }
-struct TArgs_btint84cmp_Policy {
+TExecFunc arrow_dcosh() { return TGenericExec<TPgDirectFunc<&dcosh>, true, true, TArgs_dcosh_Policy>({}); }
+struct TArgs_dcot_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_btint84cmp() { return &GenericExec<TPgDirectFunc<&btint84cmp>, true, true, TArgs_btint84cmp_Policy>; }
-struct TArgs_btint8cmp_Policy {
+TExecFunc arrow_dcot() { return TGenericExec<TPgDirectFunc<&dcot>, true, true, TArgs_dcot_Policy>({}); }
+struct TArgs_dcotd_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_btint8cmp() { return &GenericExec<TPgDirectFunc<&btint8cmp>, true, true, TArgs_btint8cmp_Policy>; }
-struct TArgs_btint8sortsupport_Policy {
+TExecFunc arrow_dcotd() { return TGenericExec<TPgDirectFunc<&dcotd>, true, true, TArgs_dcotd_Policy>({}); }
+struct TArgs_degrees_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_btint8sortsupport() { return &GenericExec<TPgDirectFunc<&btint8sortsupport>, true, true, TArgs_btint8sortsupport_Policy>; }
-struct TArgs_btoidcmp_Policy {
+TExecFunc arrow_degrees() { return TGenericExec<TPgDirectFunc<&degrees>, true, true, TArgs_degrees_Policy>({}); }
+struct TArgs_dexp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_btoidcmp() { return &GenericExec<TPgDirectFunc<&btoidcmp>, true, true, TArgs_btoidcmp_Policy>; }
-struct TArgs_btoidsortsupport_Policy {
+TExecFunc arrow_dexp() { return TGenericExec<TPgDirectFunc<&dexp>, true, true, TArgs_dexp_Policy>({}); }
+struct TArgs_dfloor_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_btoidsortsupport() { return &GenericExec<TPgDirectFunc<&btoidsortsupport>, true, true, TArgs_btoidsortsupport_Policy>; }
-struct TArgs_btoidvectorcmp_Policy {
+TExecFunc arrow_dfloor() { return TGenericExec<TPgDirectFunc<&dfloor>, true, true, TArgs_dfloor_Policy>({}); }
+struct TArgs_dispell_init_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_btoidvectorcmp() { return &GenericExec<TPgDirectFunc<&btoidvectorcmp>, true, true, TArgs_btoidvectorcmp_Policy>; }
-struct TArgs_btrim_Policy {
+TExecFunc arrow_dispell_init() { return TGenericExec<TPgDirectFunc<&dispell_init>, true, true, TArgs_dispell_init_Policy>({}); }
+struct TArgs_dispell_lexize_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_btrim() { return &GenericExec<TPgDirectFunc<&btrim>, true, false, TArgs_btrim_Policy>; }
-struct TArgs_btrim1_Policy {
+TExecFunc arrow_dispell_lexize() { return TGenericExec<TPgDirectFunc<&dispell_lexize>, true, true, TArgs_dispell_lexize_Policy>({}); }
+struct TArgs_dlog1_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_btrim1() { return &GenericExec<TPgDirectFunc<&btrim1>, true, false, TArgs_btrim1_Policy>; }
-struct TArgs_bytealike_Policy {
+TExecFunc arrow_dlog1() { return TGenericExec<TPgDirectFunc<&dlog1>, true, true, TArgs_dlog1_Policy>({}); }
+struct TArgs_dlog10_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_bytealike() { return &GenericExec<TPgDirectFunc<&bytealike>, true, true, TArgs_bytealike_Policy>; }
-struct TArgs_bytealtrim_Policy {
+TExecFunc arrow_dlog10() { return TGenericExec<TPgDirectFunc<&dlog10>, true, true, TArgs_dlog10_Policy>({}); }
+struct TArgs_domain_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_bytealtrim() { return &GenericExec<TPgDirectFunc<&bytealtrim>, true, false, TArgs_bytealtrim_Policy>; }
-struct TArgs_byteanlike_Policy {
+TExecFunc arrow_domain_in() { return TGenericExec<TPgDirectFunc<&domain_in>, false, true, TArgs_domain_in_Policy>({}); }
+struct TArgs_domain_recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_byteanlike() { return &GenericExec<TPgDirectFunc<&byteanlike>, true, true, TArgs_byteanlike_Policy>; }
-struct TArgs_byteartrim_Policy {
+TExecFunc arrow_domain_recv() { return TGenericExec<TPgDirectFunc<&domain_recv>, false, true, TArgs_domain_recv_Policy>({}); }
+struct TArgs_dpi_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_byteartrim() { return &GenericExec<TPgDirectFunc<&byteartrim>, true, false, TArgs_byteartrim_Policy>; }
-struct TArgs_byteatrim_Policy {
+TExecFunc arrow_dpi() { return TGenericExec<TPgDirectFunc<&dpi>, true, true, TArgs_dpi_Policy>({}); }
+struct TArgs_dpow_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_byteatrim() { return &GenericExec<TPgDirectFunc<&byteatrim>, true, false, TArgs_byteatrim_Policy>; }
-struct TArgs_char_bpchar_Policy {
+TExecFunc arrow_dpow() { return TGenericExec<TPgDirectFunc<&dpow>, true, true, TArgs_dpow_Policy>({}); }
+struct TArgs_drandom_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_char_bpchar() { return &GenericExec<TPgDirectFunc<&char_bpchar>, true, false, TArgs_char_bpchar_Policy>; }
-struct TArgs_chr_Policy {
+TExecFunc arrow_drandom() { return TGenericExec<TPgDirectFunc<&drandom>, true, true, TArgs_drandom_Policy>({}); }
+struct TArgs_dround_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_chr() { return &GenericExec<TPgDirectFunc<&chr>, true, false, TArgs_chr_Policy>; }
-struct TArgs_cidr_abbrev_Policy {
+TExecFunc arrow_dround() { return TGenericExec<TPgDirectFunc<&dround>, true, true, TArgs_dround_Policy>({}); }
+struct TArgs_dsign_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_cidr_abbrev() { return &GenericExec<TPgDirectFunc<&cidr_abbrev>, true, false, TArgs_cidr_abbrev_Policy>; }
-struct TArgs_cidr_in_Policy {
+TExecFunc arrow_dsign() { return TGenericExec<TPgDirectFunc<&dsign>, true, true, TArgs_dsign_Policy>({}); }
+struct TArgs_dsin_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_cidr_in() { return &GenericExec<TPgDirectFunc<&cidr_in>, true, false, TArgs_cidr_in_Policy>; }
-struct TArgs_cidr_out_Policy {
+TExecFunc arrow_dsin() { return TGenericExec<TPgDirectFunc<&dsin>, true, true, TArgs_dsin_Policy>({}); }
+struct TArgs_dsind_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_cidr_out() { return &GenericExec<TPgDirectFunc<&cidr_out>, true, false, TArgs_cidr_out_Policy>; }
-struct TArgs_cidr_recv_Policy {
+TExecFunc arrow_dsind() { return TGenericExec<TPgDirectFunc<&dsind>, true, true, TArgs_dsind_Policy>({}); }
+struct TArgs_dsinh_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_cidr_recv() { return &GenericExec<TPgDirectFunc<&cidr_recv>, true, false, TArgs_cidr_recv_Policy>; }
-struct TArgs_cidr_send_Policy {
+TExecFunc arrow_dsinh() { return TGenericExec<TPgDirectFunc<&dsinh>, true, true, TArgs_dsinh_Policy>({}); }
+struct TArgs_dsqrt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_cidr_send() { return &GenericExec<TPgDirectFunc<&cidr_send>, true, false, TArgs_cidr_send_Policy>; }
-struct TArgs_cidr_set_masklen_Policy {
+TExecFunc arrow_dsqrt() { return TGenericExec<TPgDirectFunc<&dsqrt>, true, true, TArgs_dsqrt_Policy>({}); }
+struct TArgs_dsynonym_init_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_cidr_set_masklen() { return &GenericExec<TPgDirectFunc<&cidr_set_masklen>, true, false, TArgs_cidr_set_masklen_Policy>; }
-struct TArgs_circle_above_Policy {
+TExecFunc arrow_dsynonym_init() { return TGenericExec<TPgDirectFunc<&dsynonym_init>, true, true, TArgs_dsynonym_init_Policy>({}); }
+struct TArgs_dsynonym_lexize_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_circle_above() { return &GenericExec<TPgDirectFunc<&circle_above>, true, true, TArgs_circle_above_Policy>; }
-struct TArgs_circle_add_pt_Policy {
+TExecFunc arrow_dsynonym_lexize() { return TGenericExec<TPgDirectFunc<&dsynonym_lexize>, true, true, TArgs_dsynonym_lexize_Policy>({}); }
+struct TArgs_dtan_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_circle_add_pt() { return &GenericExec<TPgDirectFunc<&circle_add_pt>, true, false, TArgs_circle_add_pt_Policy>; }
-struct TArgs_circle_area_Policy {
+TExecFunc arrow_dtan() { return TGenericExec<TPgDirectFunc<&dtan>, true, true, TArgs_dtan_Policy>({}); }
+struct TArgs_dtand_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_circle_area() { return &GenericExec<TPgDirectFunc<&circle_area>, true, true, TArgs_circle_area_Policy>; }
-struct TArgs_circle_below_Policy {
+TExecFunc arrow_dtand() { return TGenericExec<TPgDirectFunc<&dtand>, true, true, TArgs_dtand_Policy>({}); }
+struct TArgs_dtanh_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_circle_below() { return &GenericExec<TPgDirectFunc<&circle_below>, true, true, TArgs_circle_below_Policy>; }
-struct TArgs_circle_box_Policy {
+TExecFunc arrow_dtanh() { return TGenericExec<TPgDirectFunc<&dtanh>, true, true, TArgs_dtanh_Policy>({}); }
+struct TArgs_dtof_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_circle_box() { return &GenericExec<TPgDirectFunc<&circle_box>, true, false, TArgs_circle_box_Policy>; }
-struct TArgs_circle_center_Policy {
+TExecFunc arrow_dtof() { return TGenericExec<TPgDirectFunc<&dtof>, true, true, TArgs_dtof_Policy>({}); }
+struct TArgs_dtoi2_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_circle_center() { return &GenericExec<TPgDirectFunc<&circle_center>, true, false, TArgs_circle_center_Policy>; }
-struct TArgs_circle_contain_Policy {
+TExecFunc arrow_dtoi2() { return TGenericExec<TPgDirectFunc<&dtoi2>, true, true, TArgs_dtoi2_Policy>({}); }
+struct TArgs_dtoi4_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_circle_contain() { return &GenericExec<TPgDirectFunc<&circle_contain>, true, true, TArgs_circle_contain_Policy>; }
-struct TArgs_circle_contain_pt_Policy {
+TExecFunc arrow_dtoi4() { return TGenericExec<TPgDirectFunc<&dtoi4>, true, true, TArgs_dtoi4_Policy>({}); }
+struct TArgs_dtrunc_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_circle_contain_pt() { return &GenericExec<TPgDirectFunc<&circle_contain_pt>, true, true, TArgs_circle_contain_pt_Policy>; }
-struct TArgs_circle_contained_Policy {
+TExecFunc arrow_dtrunc() { return TGenericExec<TPgDirectFunc<&dtrunc>, true, true, TArgs_dtrunc_Policy>({}); }
+struct TArgs_elem_contained_by_multirange_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_circle_contained() { return &GenericExec<TPgDirectFunc<&circle_contained>, true, true, TArgs_circle_contained_Policy>; }
-struct TArgs_circle_diameter_Policy {
+TExecFunc arrow_elem_contained_by_multirange() { return TGenericExec<TPgDirectFunc<&elem_contained_by_multirange>, true, true, TArgs_elem_contained_by_multirange_Policy>({}); }
+struct TArgs_event_trigger_in_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_circle_diameter() { return &GenericExec<TPgDirectFunc<&circle_diameter>, true, true, TArgs_circle_diameter_Policy>; }
-struct TArgs_circle_distance_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_circle_distance() { return &GenericExec<TPgDirectFunc<&circle_distance>, true, true, TArgs_circle_distance_Policy>; }
-struct TArgs_circle_div_pt_Policy {
+TExecFunc arrow_event_trigger_in() { return TGenericExec<TPgDirectFunc<&event_trigger_in>, false, true, TArgs_event_trigger_in_Policy>({}); }
+struct TArgs_event_trigger_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_circle_div_pt() { return &GenericExec<TPgDirectFunc<&circle_div_pt>, true, false, TArgs_circle_div_pt_Policy>; }
-struct TArgs_circle_eq_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_circle_eq() { return &GenericExec<TPgDirectFunc<&circle_eq>, true, true, TArgs_circle_eq_Policy>; }
-struct TArgs_circle_ge_Policy {
+TExecFunc arrow_event_trigger_out() { return TGenericExec<TPgDirectFunc<&event_trigger_out>, true, false, TArgs_event_trigger_out_Policy>({}); }
+struct TArgs_fdw_handler_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_circle_ge() { return &GenericExec<TPgDirectFunc<&circle_ge>, true, true, TArgs_circle_ge_Policy>; }
-struct TArgs_circle_gt_Policy {
+TExecFunc arrow_fdw_handler_in() { return TGenericExec<TPgDirectFunc<&fdw_handler_in>, false, true, TArgs_fdw_handler_in_Policy>({}); }
+struct TArgs_fdw_handler_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_circle_gt() { return &GenericExec<TPgDirectFunc<&circle_gt>, true, true, TArgs_circle_gt_Policy>; }
-struct TArgs_circle_in_Policy {
+TExecFunc arrow_fdw_handler_out() { return TGenericExec<TPgDirectFunc<&fdw_handler_out>, true, false, TArgs_fdw_handler_out_Policy>({}); }
+struct TArgs_float48div_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_circle_in() { return &GenericExec<TPgDirectFunc<&circle_in>, true, false, TArgs_circle_in_Policy>; }
-struct TArgs_circle_le_Policy {
+TExecFunc arrow_float48div() { return TGenericExec<TPgDirectFunc<&float48div>, true, true, TArgs_float48div_Policy>({}); }
+struct TArgs_float48eq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_circle_le() { return &GenericExec<TPgDirectFunc<&circle_le>, true, true, TArgs_circle_le_Policy>; }
-struct TArgs_circle_left_Policy {
+TExecFunc arrow_float48eq() { return TGenericExec<TPgDirectFunc<&float48eq>, true, true, TArgs_float48eq_Policy>({}); }
+struct TArgs_float48ge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_circle_left() { return &GenericExec<TPgDirectFunc<&circle_left>, true, true, TArgs_circle_left_Policy>; }
-struct TArgs_circle_lt_Policy {
+TExecFunc arrow_float48ge() { return TGenericExec<TPgDirectFunc<&float48ge>, true, true, TArgs_float48ge_Policy>({}); }
+struct TArgs_float48gt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_circle_lt() { return &GenericExec<TPgDirectFunc<&circle_lt>, true, true, TArgs_circle_lt_Policy>; }
-struct TArgs_circle_mul_pt_Policy {
+TExecFunc arrow_float48gt() { return TGenericExec<TPgDirectFunc<&float48gt>, true, true, TArgs_float48gt_Policy>({}); }
+struct TArgs_float48le_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_circle_mul_pt() { return &GenericExec<TPgDirectFunc<&circle_mul_pt>, true, false, TArgs_circle_mul_pt_Policy>; }
-struct TArgs_circle_ne_Policy {
+TExecFunc arrow_float48le() { return TGenericExec<TPgDirectFunc<&float48le>, true, true, TArgs_float48le_Policy>({}); }
+struct TArgs_float48lt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_circle_ne() { return &GenericExec<TPgDirectFunc<&circle_ne>, true, true, TArgs_circle_ne_Policy>; }
-struct TArgs_circle_out_Policy {
+TExecFunc arrow_float48lt() { return TGenericExec<TPgDirectFunc<&float48lt>, true, true, TArgs_float48lt_Policy>({}); }
+struct TArgs_float48mi_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_circle_out() { return &GenericExec<TPgDirectFunc<&circle_out>, true, false, TArgs_circle_out_Policy>; }
-struct TArgs_circle_overabove_Policy {
+TExecFunc arrow_float48mi() { return TGenericExec<TPgDirectFunc<&float48mi>, true, true, TArgs_float48mi_Policy>({}); }
+struct TArgs_float48mul_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_circle_overabove() { return &GenericExec<TPgDirectFunc<&circle_overabove>, true, true, TArgs_circle_overabove_Policy>; }
-struct TArgs_circle_overbelow_Policy {
+TExecFunc arrow_float48mul() { return TGenericExec<TPgDirectFunc<&float48mul>, true, true, TArgs_float48mul_Policy>({}); }
+struct TArgs_float48ne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_circle_overbelow() { return &GenericExec<TPgDirectFunc<&circle_overbelow>, true, true, TArgs_circle_overbelow_Policy>; }
-struct TArgs_circle_overlap_Policy {
+TExecFunc arrow_float48ne() { return TGenericExec<TPgDirectFunc<&float48ne>, true, true, TArgs_float48ne_Policy>({}); }
+struct TArgs_float48pl_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_circle_overlap() { return &GenericExec<TPgDirectFunc<&circle_overlap>, true, true, TArgs_circle_overlap_Policy>; }
-struct TArgs_circle_overleft_Policy {
+TExecFunc arrow_float48pl() { return TGenericExec<TPgDirectFunc<&float48pl>, true, true, TArgs_float48pl_Policy>({}); }
+struct TArgs_float4_accum_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_circle_overleft() { return &GenericExec<TPgDirectFunc<&circle_overleft>, true, true, TArgs_circle_overleft_Policy>; }
-struct TArgs_circle_overright_Policy {
+TExecFunc arrow_float4_accum() { return TGenericExec<TPgDirectFunc<&float4_accum>, true, false, TArgs_float4_accum_Policy>({}); }
+struct TArgs_float4abs_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_circle_overright() { return &GenericExec<TPgDirectFunc<&circle_overright>, true, true, TArgs_circle_overright_Policy>; }
-struct TArgs_circle_poly_Policy {
+TExecFunc arrow_float4abs() { return TGenericExec<TPgDirectFunc<&float4abs>, true, true, TArgs_float4abs_Policy>({}); }
+struct TArgs_float4div_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_circle_poly() { return &GenericExec<TPgDirectFunc<&circle_poly>, true, false, TArgs_circle_poly_Policy>; }
-struct TArgs_circle_radius_Policy {
+TExecFunc arrow_float4div() { return TGenericExec<TPgDirectFunc<&float4div>, true, true, TArgs_float4div_Policy>({}); }
+struct TArgs_float4eq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_circle_radius() { return &GenericExec<TPgDirectFunc<&circle_radius>, true, true, TArgs_circle_radius_Policy>; }
-struct TArgs_circle_recv_Policy {
+TExecFunc arrow_float4eq() { return TGenericExec<TPgDirectFunc<&float4eq>, true, true, TArgs_float4eq_Policy>({}); }
+struct TArgs_float4ge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_circle_recv() { return &GenericExec<TPgDirectFunc<&circle_recv>, true, false, TArgs_circle_recv_Policy>; }
-struct TArgs_circle_right_Policy {
+TExecFunc arrow_float4ge() { return TGenericExec<TPgDirectFunc<&float4ge>, true, true, TArgs_float4ge_Policy>({}); }
+struct TArgs_float4gt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_circle_right() { return &GenericExec<TPgDirectFunc<&circle_right>, true, true, TArgs_circle_right_Policy>; }
-struct TArgs_circle_same_Policy {
+TExecFunc arrow_float4gt() { return TGenericExec<TPgDirectFunc<&float4gt>, true, true, TArgs_float4gt_Policy>({}); }
+struct TArgs_float4in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_circle_same() { return &GenericExec<TPgDirectFunc<&circle_same>, true, true, TArgs_circle_same_Policy>; }
-struct TArgs_circle_send_Policy {
+TExecFunc arrow_float4in() { return TGenericExec<TPgDirectFunc<&float4in>, true, true, TArgs_float4in_Policy>({}); }
+struct TArgs_float4larger_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_circle_send() { return &GenericExec<TPgDirectFunc<&circle_send>, true, false, TArgs_circle_send_Policy>; }
-struct TArgs_circle_sub_pt_Policy {
+TExecFunc arrow_float4larger() { return TGenericExec<TPgDirectFunc<&float4larger>, true, true, TArgs_float4larger_Policy>({}); }
+struct TArgs_float4le_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_circle_sub_pt() { return &GenericExec<TPgDirectFunc<&circle_sub_pt>, true, false, TArgs_circle_sub_pt_Policy>; }
-struct TArgs_close_lb_Policy {
+TExecFunc arrow_float4le() { return TGenericExec<TPgDirectFunc<&float4le>, true, true, TArgs_float4le_Policy>({}); }
+struct TArgs_float4lt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_close_lb() { return &GenericExec<TPgDirectFunc<&close_lb>, true, false, TArgs_close_lb_Policy>; }
-struct TArgs_close_ls_Policy {
+TExecFunc arrow_float4lt() { return TGenericExec<TPgDirectFunc<&float4lt>, true, true, TArgs_float4lt_Policy>({}); }
+struct TArgs_float4mi_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_close_ls() { return &GenericExec<TPgDirectFunc<&close_ls>, true, false, TArgs_close_ls_Policy>; }
-struct TArgs_close_lseg_Policy {
+TExecFunc arrow_float4mi() { return TGenericExec<TPgDirectFunc<&float4mi>, true, true, TArgs_float4mi_Policy>({}); }
+struct TArgs_float4mul_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_close_lseg() { return &GenericExec<TPgDirectFunc<&close_lseg>, true, false, TArgs_close_lseg_Policy>; }
-struct TArgs_close_pb_Policy {
+TExecFunc arrow_float4mul() { return TGenericExec<TPgDirectFunc<&float4mul>, true, true, TArgs_float4mul_Policy>({}); }
+struct TArgs_float4ne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_close_pb() { return &GenericExec<TPgDirectFunc<&close_pb>, true, false, TArgs_close_pb_Policy>; }
-struct TArgs_close_pl_Policy {
+TExecFunc arrow_float4ne() { return TGenericExec<TPgDirectFunc<&float4ne>, true, true, TArgs_float4ne_Policy>({}); }
+struct TArgs_float4out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_close_pl() { return &GenericExec<TPgDirectFunc<&close_pl>, true, false, TArgs_close_pl_Policy>; }
-struct TArgs_close_ps_Policy {
+TExecFunc arrow_float4out() { return TGenericExec<TPgDirectFunc<&float4out>, true, false, TArgs_float4out_Policy>({}); }
+struct TArgs_float4pl_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_close_ps() { return &GenericExec<TPgDirectFunc<&close_ps>, true, false, TArgs_close_ps_Policy>; }
-struct TArgs_close_sb_Policy {
+TExecFunc arrow_float4pl() { return TGenericExec<TPgDirectFunc<&float4pl>, true, true, TArgs_float4pl_Policy>({}); }
+struct TArgs_float4recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_close_sb() { return &GenericExec<TPgDirectFunc<&close_sb>, true, false, TArgs_close_sb_Policy>; }
-struct TArgs_close_sl_Policy {
+TExecFunc arrow_float4recv() { return TGenericExec<TPgDirectFunc<&float4recv>, true, true, TArgs_float4recv_Policy>({}); }
+struct TArgs_float4send_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_close_sl() { return &GenericExec<TPgDirectFunc<&close_sl>, true, false, TArgs_close_sl_Policy>; }
-struct TArgs_construct_point_Policy {
+TExecFunc arrow_float4send() { return TGenericExec<TPgDirectFunc<&float4send>, true, false, TArgs_float4send_Policy>({}); }
+struct TArgs_float4smaller_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_construct_point() { return &GenericExec<TPgDirectFunc<&construct_point>, true, false, TArgs_construct_point_Policy>; }
-struct TArgs_cr_circle_Policy {
+TExecFunc arrow_float4smaller() { return TGenericExec<TPgDirectFunc<&float4smaller>, true, true, TArgs_float4smaller_Policy>({}); }
+struct TArgs_float4um_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_cr_circle() { return &GenericExec<TPgDirectFunc<&cr_circle>, true, false, TArgs_cr_circle_Policy>; }
-struct TArgs_dispell_init_Policy {
+TExecFunc arrow_float4um() { return TGenericExec<TPgDirectFunc<&float4um>, true, true, TArgs_float4um_Policy>({}); }
+struct TArgs_float4up_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_dispell_init() { return &GenericExec<TPgDirectFunc<&dispell_init>, true, true, TArgs_dispell_init_Policy>; }
-struct TArgs_dispell_lexize_Policy {
+TExecFunc arrow_float4up() { return TGenericExec<TPgDirectFunc<&float4up>, true, true, TArgs_float4up_Policy>({}); }
+struct TArgs_float84div_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_dispell_lexize() { return &GenericExec<TPgDirectFunc<&dispell_lexize>, true, true, TArgs_dispell_lexize_Policy>; }
-struct TArgs_dist_bl_Policy {
+TExecFunc arrow_float84div() { return TGenericExec<TPgDirectFunc<&float84div>, true, true, TArgs_float84div_Policy>({}); }
+struct TArgs_float84eq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_dist_bl() { return &GenericExec<TPgDirectFunc<&dist_bl>, true, true, TArgs_dist_bl_Policy>; }
-struct TArgs_dist_bp_Policy {
+TExecFunc arrow_float84eq() { return TGenericExec<TPgDirectFunc<&float84eq>, true, true, TArgs_float84eq_Policy>({}); }
+struct TArgs_float84ge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_dist_bp() { return &GenericExec<TPgDirectFunc<&dist_bp>, true, true, TArgs_dist_bp_Policy>; }
-struct TArgs_dist_bs_Policy {
+TExecFunc arrow_float84ge() { return TGenericExec<TPgDirectFunc<&float84ge>, true, true, TArgs_float84ge_Policy>({}); }
+struct TArgs_float84gt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_dist_bs() { return &GenericExec<TPgDirectFunc<&dist_bs>, true, true, TArgs_dist_bs_Policy>; }
-struct TArgs_dist_cpoint_Policy {
+TExecFunc arrow_float84gt() { return TGenericExec<TPgDirectFunc<&float84gt>, true, true, TArgs_float84gt_Policy>({}); }
+struct TArgs_float84le_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_dist_cpoint() { return &GenericExec<TPgDirectFunc<&dist_cpoint>, true, true, TArgs_dist_cpoint_Policy>; }
-struct TArgs_dist_cpoly_Policy {
+TExecFunc arrow_float84le() { return TGenericExec<TPgDirectFunc<&float84le>, true, true, TArgs_float84le_Policy>({}); }
+struct TArgs_float84lt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_dist_cpoly() { return &GenericExec<TPgDirectFunc<&dist_cpoly>, true, true, TArgs_dist_cpoly_Policy>; }
-struct TArgs_dist_lb_Policy {
+TExecFunc arrow_float84lt() { return TGenericExec<TPgDirectFunc<&float84lt>, true, true, TArgs_float84lt_Policy>({}); }
+struct TArgs_float84mi_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_dist_lb() { return &GenericExec<TPgDirectFunc<&dist_lb>, true, true, TArgs_dist_lb_Policy>; }
-struct TArgs_dist_lp_Policy {
+TExecFunc arrow_float84mi() { return TGenericExec<TPgDirectFunc<&float84mi>, true, true, TArgs_float84mi_Policy>({}); }
+struct TArgs_float84mul_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_dist_lp() { return &GenericExec<TPgDirectFunc<&dist_lp>, true, true, TArgs_dist_lp_Policy>; }
-struct TArgs_dist_ls_Policy {
+TExecFunc arrow_float84mul() { return TGenericExec<TPgDirectFunc<&float84mul>, true, true, TArgs_float84mul_Policy>({}); }
+struct TArgs_float84ne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_dist_ls() { return &GenericExec<TPgDirectFunc<&dist_ls>, true, true, TArgs_dist_ls_Policy>; }
-struct TArgs_dist_pathp_Policy {
+TExecFunc arrow_float84ne() { return TGenericExec<TPgDirectFunc<&float84ne>, true, true, TArgs_float84ne_Policy>({}); }
+struct TArgs_float84pl_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_dist_pathp() { return &GenericExec<TPgDirectFunc<&dist_pathp>, true, true, TArgs_dist_pathp_Policy>; }
-struct TArgs_dist_pb_Policy {
+TExecFunc arrow_float84pl() { return TGenericExec<TPgDirectFunc<&float84pl>, true, true, TArgs_float84pl_Policy>({}); }
+struct TArgs_float8_accum_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_dist_pb() { return &GenericExec<TPgDirectFunc<&dist_pb>, true, true, TArgs_dist_pb_Policy>; }
-struct TArgs_dist_pc_Policy {
+TExecFunc arrow_float8_accum() { return TGenericExec<TPgDirectFunc<&float8_accum>, true, false, TArgs_float8_accum_Policy>({}); }
+struct TArgs_float8_avg_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_dist_pc() { return &GenericExec<TPgDirectFunc<&dist_pc>, true, true, TArgs_dist_pc_Policy>; }
-struct TArgs_dist_pl_Policy {
+TExecFunc arrow_float8_avg() { return TGenericExec<TPgDirectFunc<&float8_avg>, true, true, TArgs_float8_avg_Policy>({}); }
+struct TArgs_float8_combine_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_dist_pl() { return &GenericExec<TPgDirectFunc<&dist_pl>, true, true, TArgs_dist_pl_Policy>; }
-struct TArgs_dist_polyc_Policy {
+TExecFunc arrow_float8_combine() { return TGenericExec<TPgDirectFunc<&float8_combine>, true, false, TArgs_float8_combine_Policy>({}); }
+struct TArgs_float8_corr_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_dist_polyc() { return &GenericExec<TPgDirectFunc<&dist_polyc>, true, true, TArgs_dist_polyc_Policy>; }
-struct TArgs_dist_polyp_Policy {
+TExecFunc arrow_float8_corr() { return TGenericExec<TPgDirectFunc<&float8_corr>, true, true, TArgs_float8_corr_Policy>({}); }
+struct TArgs_float8_covar_pop_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_dist_polyp() { return &GenericExec<TPgDirectFunc<&dist_polyp>, true, true, TArgs_dist_polyp_Policy>; }
-struct TArgs_dist_ppath_Policy {
+TExecFunc arrow_float8_covar_pop() { return TGenericExec<TPgDirectFunc<&float8_covar_pop>, true, true, TArgs_float8_covar_pop_Policy>({}); }
+struct TArgs_float8_covar_samp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_dist_ppath() { return &GenericExec<TPgDirectFunc<&dist_ppath>, true, true, TArgs_dist_ppath_Policy>; }
-struct TArgs_dist_ppoly_Policy {
+TExecFunc arrow_float8_covar_samp() { return TGenericExec<TPgDirectFunc<&float8_covar_samp>, true, true, TArgs_float8_covar_samp_Policy>({}); }
+struct TArgs_float8_regr_accum_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_dist_ppoly() { return &GenericExec<TPgDirectFunc<&dist_ppoly>, true, true, TArgs_dist_ppoly_Policy>; }
-struct TArgs_dist_ps_Policy {
+TExecFunc arrow_float8_regr_accum() { return TGenericExec<TPgDirectFunc<&float8_regr_accum>, true, false, TArgs_float8_regr_accum_Policy>({}); }
+struct TArgs_float8_regr_avgx_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_dist_ps() { return &GenericExec<TPgDirectFunc<&dist_ps>, true, true, TArgs_dist_ps_Policy>; }
-struct TArgs_dist_sb_Policy {
+TExecFunc arrow_float8_regr_avgx() { return TGenericExec<TPgDirectFunc<&float8_regr_avgx>, true, true, TArgs_float8_regr_avgx_Policy>({}); }
+struct TArgs_float8_regr_avgy_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_dist_sb() { return &GenericExec<TPgDirectFunc<&dist_sb>, true, true, TArgs_dist_sb_Policy>; }
-struct TArgs_dist_sl_Policy {
+TExecFunc arrow_float8_regr_avgy() { return TGenericExec<TPgDirectFunc<&float8_regr_avgy>, true, true, TArgs_float8_regr_avgy_Policy>({}); }
+struct TArgs_float8_regr_combine_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_dist_sl() { return &GenericExec<TPgDirectFunc<&dist_sl>, true, true, TArgs_dist_sl_Policy>; }
-struct TArgs_dist_sp_Policy {
+TExecFunc arrow_float8_regr_combine() { return TGenericExec<TPgDirectFunc<&float8_regr_combine>, true, false, TArgs_float8_regr_combine_Policy>({}); }
+struct TArgs_float8_regr_intercept_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_dist_sp() { return &GenericExec<TPgDirectFunc<&dist_sp>, true, true, TArgs_dist_sp_Policy>; }
-struct TArgs_dsynonym_init_Policy {
+TExecFunc arrow_float8_regr_intercept() { return TGenericExec<TPgDirectFunc<&float8_regr_intercept>, true, true, TArgs_float8_regr_intercept_Policy>({}); }
+struct TArgs_float8_regr_r2_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_dsynonym_init() { return &GenericExec<TPgDirectFunc<&dsynonym_init>, true, true, TArgs_dsynonym_init_Policy>; }
-struct TArgs_dsynonym_lexize_Policy {
+TExecFunc arrow_float8_regr_r2() { return TGenericExec<TPgDirectFunc<&float8_regr_r2>, true, true, TArgs_float8_regr_r2_Policy>({}); }
+struct TArgs_float8_regr_slope_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_dsynonym_lexize() { return &GenericExec<TPgDirectFunc<&dsynonym_lexize>, true, true, TArgs_dsynonym_lexize_Policy>; }
-struct TArgs_enum_cmp_Policy {
+TExecFunc arrow_float8_regr_slope() { return TGenericExec<TPgDirectFunc<&float8_regr_slope>, true, true, TArgs_float8_regr_slope_Policy>({}); }
+struct TArgs_float8_regr_sxx_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_enum_cmp() { return &GenericExec<TPgDirectFunc<&enum_cmp>, true, true, TArgs_enum_cmp_Policy>; }
-struct TArgs_enum_eq_Policy {
+TExecFunc arrow_float8_regr_sxx() { return TGenericExec<TPgDirectFunc<&float8_regr_sxx>, true, true, TArgs_float8_regr_sxx_Policy>({}); }
+struct TArgs_float8_regr_sxy_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_enum_eq() { return &GenericExec<TPgDirectFunc<&enum_eq>, true, true, TArgs_enum_eq_Policy>; }
-struct TArgs_enum_first_Policy {
+TExecFunc arrow_float8_regr_sxy() { return TGenericExec<TPgDirectFunc<&float8_regr_sxy>, true, true, TArgs_float8_regr_sxy_Policy>({}); }
+struct TArgs_float8_regr_syy_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_enum_first() { return &GenericExec<TPgDirectFunc<&enum_first>, false, true, TArgs_enum_first_Policy>; }
-struct TArgs_enum_ge_Policy {
+TExecFunc arrow_float8_regr_syy() { return TGenericExec<TPgDirectFunc<&float8_regr_syy>, true, true, TArgs_float8_regr_syy_Policy>({}); }
+struct TArgs_float8_stddev_pop_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_enum_ge() { return &GenericExec<TPgDirectFunc<&enum_ge>, true, true, TArgs_enum_ge_Policy>; }
-struct TArgs_enum_gt_Policy {
+TExecFunc arrow_float8_stddev_pop() { return TGenericExec<TPgDirectFunc<&float8_stddev_pop>, true, true, TArgs_float8_stddev_pop_Policy>({}); }
+struct TArgs_float8_stddev_samp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_enum_gt() { return &GenericExec<TPgDirectFunc<&enum_gt>, true, true, TArgs_enum_gt_Policy>; }
-struct TArgs_enum_in_Policy {
+TExecFunc arrow_float8_stddev_samp() { return TGenericExec<TPgDirectFunc<&float8_stddev_samp>, true, true, TArgs_float8_stddev_samp_Policy>({}); }
+struct TArgs_float8_var_pop_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_enum_in() { return &GenericExec<TPgDirectFunc<&enum_in>, true, true, TArgs_enum_in_Policy>; }
-struct TArgs_enum_larger_Policy {
+TExecFunc arrow_float8_var_pop() { return TGenericExec<TPgDirectFunc<&float8_var_pop>, true, true, TArgs_float8_var_pop_Policy>({}); }
+struct TArgs_float8_var_samp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_enum_larger() { return &GenericExec<TPgDirectFunc<&enum_larger>, true, true, TArgs_enum_larger_Policy>; }
-struct TArgs_enum_last_Policy {
+TExecFunc arrow_float8_var_samp() { return TGenericExec<TPgDirectFunc<&float8_var_samp>, true, true, TArgs_float8_var_samp_Policy>({}); }
+struct TArgs_float8abs_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_enum_last() { return &GenericExec<TPgDirectFunc<&enum_last>, false, true, TArgs_enum_last_Policy>; }
-struct TArgs_enum_le_Policy {
+TExecFunc arrow_float8abs() { return TGenericExec<TPgDirectFunc<&float8abs>, true, true, TArgs_float8abs_Policy>({}); }
+struct TArgs_float8div_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_enum_le() { return &GenericExec<TPgDirectFunc<&enum_le>, true, true, TArgs_enum_le_Policy>; }
-struct TArgs_enum_lt_Policy {
+TExecFunc arrow_float8div() { return TGenericExec<TPgDirectFunc<&float8div>, true, true, TArgs_float8div_Policy>({}); }
+struct TArgs_float8eq_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_enum_lt() { return &GenericExec<TPgDirectFunc<&enum_lt>, true, true, TArgs_enum_lt_Policy>; }
-struct TArgs_enum_ne_Policy {
+TExecFunc arrow_float8eq() { return TGenericExec<TPgDirectFunc<&float8eq>, true, true, TArgs_float8eq_Policy>({}); }
+struct TArgs_float8ge_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_enum_ne() { return &GenericExec<TPgDirectFunc<&enum_ne>, true, true, TArgs_enum_ne_Policy>; }
-struct TArgs_enum_out_Policy {
+TExecFunc arrow_float8ge() { return TGenericExec<TPgDirectFunc<&float8ge>, true, true, TArgs_float8ge_Policy>({}); }
+struct TArgs_float8gt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_enum_out() { return &GenericExec<TPgDirectFunc<&enum_out>, true, false, TArgs_enum_out_Policy>; }
-struct TArgs_enum_range_all_Policy {
+TExecFunc arrow_float8gt() { return TGenericExec<TPgDirectFunc<&float8gt>, true, true, TArgs_float8gt_Policy>({}); }
+struct TArgs_float8in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_enum_range_all() { return &GenericExec<TPgDirectFunc<&enum_range_all>, false, false, TArgs_enum_range_all_Policy>; }
-struct TArgs_enum_range_bounds_Policy {
+TExecFunc arrow_float8in() { return TGenericExec<TPgDirectFunc<&float8in>, true, true, TArgs_float8in_Policy>({}); }
+struct TArgs_float8larger_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_enum_range_bounds() { return &GenericExec<TPgDirectFunc<&enum_range_bounds>, false, false, TArgs_enum_range_bounds_Policy>; }
-struct TArgs_enum_recv_Policy {
+TExecFunc arrow_float8larger() { return TGenericExec<TPgDirectFunc<&float8larger>, true, true, TArgs_float8larger_Policy>({}); }
+struct TArgs_float8le_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_enum_recv() { return &GenericExec<TPgDirectFunc<&enum_recv>, true, true, TArgs_enum_recv_Policy>; }
-struct TArgs_enum_send_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_enum_send() { return &GenericExec<TPgDirectFunc<&enum_send>, true, false, TArgs_enum_send_Policy>; }
-struct TArgs_enum_smaller_Policy {
+TExecFunc arrow_float8le() { return TGenericExec<TPgDirectFunc<&float8le>, true, true, TArgs_float8le_Policy>({}); }
+struct TArgs_float8lt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_enum_smaller() { return &GenericExec<TPgDirectFunc<&enum_smaller>, true, true, TArgs_enum_smaller_Policy>; }
-struct TArgs_eqjoinsel_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
-};
-TExecFunc arrow_eqjoinsel() { return &GenericExec<TPgDirectFunc<&eqjoinsel>, true, true, TArgs_eqjoinsel_Policy>; }
-struct TArgs_eqsel_Policy {
+TExecFunc arrow_float8lt() { return TGenericExec<TPgDirectFunc<&float8lt>, true, true, TArgs_float8lt_Policy>({}); }
+struct TArgs_float8mi_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_eqsel() { return &GenericExec<TPgDirectFunc<&eqsel>, true, true, TArgs_eqsel_Policy>; }
-struct TArgs_float4_to_char_Policy {
+TExecFunc arrow_float8mi() { return TGenericExec<TPgDirectFunc<&float8mi>, true, true, TArgs_float8mi_Policy>({}); }
+struct TArgs_float8mul_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_float4_to_char() { return &GenericExec<TPgDirectFunc<&float4_to_char>, true, false, TArgs_float4_to_char_Policy>; }
-struct TArgs_float8_to_char_Policy {
+TExecFunc arrow_float8mul() { return TGenericExec<TPgDirectFunc<&float8mul>, true, true, TArgs_float8mul_Policy>({}); }
+struct TArgs_float8ne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_float8_to_char() { return &GenericExec<TPgDirectFunc<&float8_to_char>, true, false, TArgs_float8_to_char_Policy>; }
-struct TArgs_fmgr_c_validator_Policy {
+TExecFunc arrow_float8ne() { return TGenericExec<TPgDirectFunc<&float8ne>, true, true, TArgs_float8ne_Policy>({}); }
+struct TArgs_float8out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_fmgr_c_validator() { return &GenericExec<TPgDirectFunc<&fmgr_c_validator>, true, true, TArgs_fmgr_c_validator_Policy>; }
-struct TArgs_fmgr_internal_validator_Policy {
+TExecFunc arrow_float8out() { return TGenericExec<TPgDirectFunc<&float8out>, true, false, TArgs_float8out_Policy>({}); }
+struct TArgs_float8pl_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_fmgr_internal_validator() { return &GenericExec<TPgDirectFunc<&fmgr_internal_validator>, true, true, TArgs_fmgr_internal_validator_Policy>; }
-struct TArgs_fmgr_sql_validator_Policy {
+TExecFunc arrow_float8pl() { return TGenericExec<TPgDirectFunc<&float8pl>, true, true, TArgs_float8pl_Policy>({}); }
+struct TArgs_float8recv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_fmgr_sql_validator() { return &GenericExec<TPgDirectFunc<&fmgr_sql_validator>, true, true, TArgs_fmgr_sql_validator_Policy>; }
-struct TArgs_gen_random_uuid_Policy {
+TExecFunc arrow_float8recv() { return TGenericExec<TPgDirectFunc<&float8recv>, true, true, TArgs_float8recv_Policy>({}); }
+struct TArgs_float8send_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
-};
-TExecFunc arrow_gen_random_uuid() { return &GenericExec<TPgDirectFunc<&gen_random_uuid>, true, false, TArgs_gen_random_uuid_Policy>; }
-struct TArgs_getdatabaseencoding_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
-};
-TExecFunc arrow_getdatabaseencoding() { return &GenericExec<TPgDirectFunc<&getdatabaseencoding>, true, false, TArgs_getdatabaseencoding_Policy>; }
-struct TArgs_gin_cmp_prefix_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,false,true,true};
-};
-TExecFunc arrow_gin_cmp_prefix() { return &GenericExec<TPgDirectFunc<&gin_cmp_prefix>, true, true, TArgs_gin_cmp_prefix_Policy>; }
-struct TArgs_gin_cmp_tslexeme_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_gin_cmp_tslexeme() { return &GenericExec<TPgDirectFunc<&gin_cmp_tslexeme>, true, true, TArgs_gin_cmp_tslexeme_Policy>; }
-struct TArgs_gin_extract_tsquery_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 7> IsFixedArg = {false,true,true,true,true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_gin_extract_tsquery() { return &GenericExec<TPgDirectFunc<&gin_extract_tsquery>, true, true, TArgs_gin_extract_tsquery_Policy>; }
-struct TArgs_gin_extract_tsquery_5args_Policy {
+TExecFunc arrow_float8send() { return TGenericExec<TPgDirectFunc<&float8send>, true, false, TArgs_float8send_Policy>({}); }
+struct TArgs_float8smaller_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {false,true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_gin_extract_tsquery_5args() { return &GenericExec<TPgDirectFunc<&gin_extract_tsquery_5args>, true, true, TArgs_gin_extract_tsquery_5args_Policy>; }
-struct TArgs_gin_extract_tsquery_oldsig_Policy {
+TExecFunc arrow_float8smaller() { return TGenericExec<TPgDirectFunc<&float8smaller>, true, true, TArgs_float8smaller_Policy>({}); }
+struct TArgs_float8um_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 7> IsFixedArg = {false,true,true,true,true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_gin_extract_tsquery_oldsig() { return &GenericExec<TPgDirectFunc<&gin_extract_tsquery_oldsig>, true, true, TArgs_gin_extract_tsquery_oldsig_Policy>; }
-struct TArgs_gin_extract_tsvector_Policy {
+TExecFunc arrow_float8um() { return TGenericExec<TPgDirectFunc<&float8um>, true, true, TArgs_float8um_Policy>({}); }
+struct TArgs_float8up_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_gin_extract_tsvector() { return &GenericExec<TPgDirectFunc<&gin_extract_tsvector>, true, true, TArgs_gin_extract_tsvector_Policy>; }
-struct TArgs_gin_extract_tsvector_2args_Policy {
+TExecFunc arrow_float8up() { return TGenericExec<TPgDirectFunc<&float8up>, true, true, TArgs_float8up_Policy>({}); }
+struct TArgs_ftod_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_gin_extract_tsvector_2args() { return &GenericExec<TPgDirectFunc<&gin_extract_tsvector_2args>, true, true, TArgs_gin_extract_tsvector_2args_Policy>; }
-struct TArgs_gin_tsquery_consistent_Policy {
+TExecFunc arrow_ftod() { return TGenericExec<TPgDirectFunc<&ftod>, true, true, TArgs_ftod_Policy>({}); }
+struct TArgs_ftoi2_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 8> IsFixedArg = {true,true,false,true,true,true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_gin_tsquery_consistent() { return &GenericExec<TPgDirectFunc<&gin_tsquery_consistent>, true, true, TArgs_gin_tsquery_consistent_Policy>; }
-struct TArgs_gin_tsquery_consistent_6args_Policy {
+TExecFunc arrow_ftoi2() { return TGenericExec<TPgDirectFunc<&ftoi2>, true, true, TArgs_ftoi2_Policy>({}); }
+struct TArgs_ftoi4_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 6> IsFixedArg = {true,true,false,true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_gin_tsquery_consistent_6args() { return &GenericExec<TPgDirectFunc<&gin_tsquery_consistent_6args>, true, true, TArgs_gin_tsquery_consistent_6args_Policy>; }
-struct TArgs_gin_tsquery_consistent_oldsig_Policy {
+TExecFunc arrow_ftoi4() { return TGenericExec<TPgDirectFunc<&ftoi4>, true, true, TArgs_ftoi4_Policy>({}); }
+struct TArgs_gin_clean_pending_list_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 8> IsFixedArg = {true,true,false,true,true,true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_gin_tsquery_consistent_oldsig() { return &GenericExec<TPgDirectFunc<&gin_tsquery_consistent_oldsig>, true, true, TArgs_gin_tsquery_consistent_oldsig_Policy>; }
-struct TArgs_gin_tsquery_triconsistent_Policy {
+TExecFunc arrow_gin_clean_pending_list() { return TGenericExec<TPgDirectFunc<&gin_clean_pending_list>, true, true, TArgs_gin_clean_pending_list_Policy>({}); }
+struct TArgs_ginhandler_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 7> IsFixedArg = {true,true,false,true,true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_gin_tsquery_triconsistent() { return &GenericExec<TPgDirectFunc<&gin_tsquery_triconsistent>, true, true, TArgs_gin_tsquery_triconsistent_Policy>; }
+TExecFunc arrow_ginhandler() { return TGenericExec<TPgDirectFunc<&ginhandler>, true, true, TArgs_ginhandler_Policy>({}); }
 struct TArgs_gist_box_consistent_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 5> IsFixedArg = {true,false,true,true,true};
 };
-TExecFunc arrow_gist_box_consistent() { return &GenericExec<TPgDirectFunc<&gist_box_consistent>, true, true, TArgs_gist_box_consistent_Policy>; }
+TExecFunc arrow_gist_box_consistent() { return TGenericExec<TPgDirectFunc<&gist_box_consistent>, true, true, TArgs_gist_box_consistent_Policy>({}); }
 struct TArgs_gist_box_distance_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 5> IsFixedArg = {true,false,true,true,true};
 };
-TExecFunc arrow_gist_box_distance() { return &GenericExec<TPgDirectFunc<&gist_box_distance>, true, true, TArgs_gist_box_distance_Policy>; }
+TExecFunc arrow_gist_box_distance() { return TGenericExec<TPgDirectFunc<&gist_box_distance>, true, true, TArgs_gist_box_distance_Policy>({}); }
 struct TArgs_gist_box_penalty_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_gist_box_penalty() { return &GenericExec<TPgDirectFunc<&gist_box_penalty>, true, true, TArgs_gist_box_penalty_Policy>; }
+TExecFunc arrow_gist_box_penalty() { return TGenericExec<TPgDirectFunc<&gist_box_penalty>, true, true, TArgs_gist_box_penalty_Policy>({}); }
 struct TArgs_gist_box_picksplit_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_gist_box_picksplit() { return &GenericExec<TPgDirectFunc<&gist_box_picksplit>, true, true, TArgs_gist_box_picksplit_Policy>; }
+TExecFunc arrow_gist_box_picksplit() { return TGenericExec<TPgDirectFunc<&gist_box_picksplit>, true, true, TArgs_gist_box_picksplit_Policy>({}); }
 struct TArgs_gist_box_same_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {false,false,true};
 };
-TExecFunc arrow_gist_box_same() { return &GenericExec<TPgDirectFunc<&gist_box_same>, true, true, TArgs_gist_box_same_Policy>; }
+TExecFunc arrow_gist_box_same() { return TGenericExec<TPgDirectFunc<&gist_box_same>, true, true, TArgs_gist_box_same_Policy>({}); }
 struct TArgs_gist_box_union_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_gist_box_union() { return &GenericExec<TPgDirectFunc<&gist_box_union>, true, false, TArgs_gist_box_union_Policy>; }
+TExecFunc arrow_gist_box_union() { return TGenericExec<TPgDirectFunc<&gist_box_union>, true, false, TArgs_gist_box_union_Policy>({}); }
 struct TArgs_gist_circle_compress_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_gist_circle_compress() { return &GenericExec<TPgDirectFunc<&gist_circle_compress>, true, true, TArgs_gist_circle_compress_Policy>; }
+TExecFunc arrow_gist_circle_compress() { return TGenericExec<TPgDirectFunc<&gist_circle_compress>, true, true, TArgs_gist_circle_compress_Policy>({}); }
 struct TArgs_gist_circle_consistent_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 5> IsFixedArg = {true,false,true,true,true};
 };
-TExecFunc arrow_gist_circle_consistent() { return &GenericExec<TPgDirectFunc<&gist_circle_consistent>, true, true, TArgs_gist_circle_consistent_Policy>; }
+TExecFunc arrow_gist_circle_consistent() { return TGenericExec<TPgDirectFunc<&gist_circle_consistent>, true, true, TArgs_gist_circle_consistent_Policy>({}); }
 struct TArgs_gist_circle_distance_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 5> IsFixedArg = {true,false,true,true,true};
 };
-TExecFunc arrow_gist_circle_distance() { return &GenericExec<TPgDirectFunc<&gist_circle_distance>, true, true, TArgs_gist_circle_distance_Policy>; }
+TExecFunc arrow_gist_circle_distance() { return TGenericExec<TPgDirectFunc<&gist_circle_distance>, true, true, TArgs_gist_circle_distance_Policy>({}); }
 struct TArgs_gist_point_compress_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_gist_point_compress() { return &GenericExec<TPgDirectFunc<&gist_point_compress>, true, true, TArgs_gist_point_compress_Policy>; }
+TExecFunc arrow_gist_point_compress() { return TGenericExec<TPgDirectFunc<&gist_point_compress>, true, true, TArgs_gist_point_compress_Policy>({}); }
 struct TArgs_gist_point_consistent_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 5> IsFixedArg = {true,false,true,true,true};
 };
-TExecFunc arrow_gist_point_consistent() { return &GenericExec<TPgDirectFunc<&gist_point_consistent>, true, true, TArgs_gist_point_consistent_Policy>; }
+TExecFunc arrow_gist_point_consistent() { return TGenericExec<TPgDirectFunc<&gist_point_consistent>, true, true, TArgs_gist_point_consistent_Policy>({}); }
 struct TArgs_gist_point_distance_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 5> IsFixedArg = {true,false,true,true,true};
 };
-TExecFunc arrow_gist_point_distance() { return &GenericExec<TPgDirectFunc<&gist_point_distance>, true, true, TArgs_gist_point_distance_Policy>; }
+TExecFunc arrow_gist_point_distance() { return TGenericExec<TPgDirectFunc<&gist_point_distance>, true, true, TArgs_gist_point_distance_Policy>({}); }
 struct TArgs_gist_point_fetch_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_gist_point_fetch() { return &GenericExec<TPgDirectFunc<&gist_point_fetch>, true, true, TArgs_gist_point_fetch_Policy>; }
+TExecFunc arrow_gist_point_fetch() { return TGenericExec<TPgDirectFunc<&gist_point_fetch>, true, true, TArgs_gist_point_fetch_Policy>({}); }
 struct TArgs_gist_point_sortsupport_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_gist_point_sortsupport() { return &GenericExec<TPgDirectFunc<&gist_point_sortsupport>, true, true, TArgs_gist_point_sortsupport_Policy>; }
+TExecFunc arrow_gist_point_sortsupport() { return TGenericExec<TPgDirectFunc<&gist_point_sortsupport>, true, true, TArgs_gist_point_sortsupport_Policy>({}); }
 struct TArgs_gist_poly_compress_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_gist_poly_compress() { return &GenericExec<TPgDirectFunc<&gist_poly_compress>, true, true, TArgs_gist_poly_compress_Policy>; }
+TExecFunc arrow_gist_poly_compress() { return TGenericExec<TPgDirectFunc<&gist_poly_compress>, true, true, TArgs_gist_poly_compress_Policy>({}); }
 struct TArgs_gist_poly_consistent_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 5> IsFixedArg = {true,false,true,true,true};
 };
-TExecFunc arrow_gist_poly_consistent() { return &GenericExec<TPgDirectFunc<&gist_poly_consistent>, true, true, TArgs_gist_poly_consistent_Policy>; }
+TExecFunc arrow_gist_poly_consistent() { return TGenericExec<TPgDirectFunc<&gist_poly_consistent>, true, true, TArgs_gist_poly_consistent_Policy>({}); }
 struct TArgs_gist_poly_distance_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 5> IsFixedArg = {true,false,true,true,true};
 };
-TExecFunc arrow_gist_poly_distance() { return &GenericExec<TPgDirectFunc<&gist_poly_distance>, true, true, TArgs_gist_poly_distance_Policy>; }
-struct TArgs_has_any_column_privilege_id_Policy {
+TExecFunc arrow_gist_poly_distance() { return TGenericExec<TPgDirectFunc<&gist_poly_distance>, true, true, TArgs_gist_poly_distance_Policy>({}); }
+struct TArgs_hash_multirange_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_has_any_column_privilege_id() { return &GenericExec<TPgDirectFunc<&has_any_column_privilege_id>, true, true, TArgs_has_any_column_privilege_id_Policy>; }
-struct TArgs_has_any_column_privilege_id_id_Policy {
+TExecFunc arrow_hash_multirange() { return TGenericExec<TPgDirectFunc<&hash_multirange>, true, true, TArgs_hash_multirange_Policy>({}); }
+struct TArgs_hash_multirange_extended_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_has_any_column_privilege_id_id() { return &GenericExec<TPgDirectFunc<&has_any_column_privilege_id_id>, true, true, TArgs_has_any_column_privilege_id_id_Policy>; }
-struct TArgs_has_any_column_privilege_id_name_Policy {
+TExecFunc arrow_hash_multirange_extended() { return TGenericExec<TPgDirectFunc<&hash_multirange_extended>, true, true, TArgs_hash_multirange_extended_Policy>({}); }
+struct TArgs_hash_record_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_has_any_column_privilege_id_name() { return &GenericExec<TPgDirectFunc<&has_any_column_privilege_id_name>, true, true, TArgs_has_any_column_privilege_id_name_Policy>; }
-struct TArgs_has_any_column_privilege_name_Policy {
+TExecFunc arrow_hash_record() { return TGenericExec<TPgDirectFunc<&hash_record>, true, true, TArgs_hash_record_Policy>({}); }
+struct TArgs_hash_record_extended_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_has_any_column_privilege_name() { return &GenericExec<TPgDirectFunc<&has_any_column_privilege_name>, true, true, TArgs_has_any_column_privilege_name_Policy>; }
-struct TArgs_has_any_column_privilege_name_id_Policy {
+TExecFunc arrow_hash_record_extended() { return TGenericExec<TPgDirectFunc<&hash_record_extended>, true, true, TArgs_hash_record_extended_Policy>({}); }
+struct TArgs_hashbpchar_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_has_any_column_privilege_name_id() { return &GenericExec<TPgDirectFunc<&has_any_column_privilege_name_id>, true, true, TArgs_has_any_column_privilege_name_id_Policy>; }
-struct TArgs_has_any_column_privilege_name_name_Policy {
+TExecFunc arrow_hashbpchar() { return TGenericExec<TPgDirectFunc<&hashbpchar>, true, true, TArgs_hashbpchar_Policy>({}); }
+struct TArgs_hashbpcharextended_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_has_any_column_privilege_name_name() { return &GenericExec<TPgDirectFunc<&has_any_column_privilege_name_name>, true, true, TArgs_has_any_column_privilege_name_name_Policy>; }
-struct TArgs_has_column_privilege_id_attnum_Policy {
+TExecFunc arrow_hashbpcharextended() { return TGenericExec<TPgDirectFunc<&hashbpcharextended>, true, true, TArgs_hashbpcharextended_Policy>({}); }
+struct TArgs_hashhandler_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_has_column_privilege_id_attnum() { return &GenericExec<TPgDirectFunc<&has_column_privilege_id_attnum>, true, true, TArgs_has_column_privilege_id_attnum_Policy>; }
-struct TArgs_has_column_privilege_id_id_attnum_Policy {
+TExecFunc arrow_hashhandler() { return TGenericExec<TPgDirectFunc<&hashhandler>, true, true, TArgs_hashhandler_Policy>({}); }
+struct TArgs_hashmacaddr_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_hashmacaddr() { return TGenericExec<TPgDirectFunc<&hashmacaddr>, true, true, TArgs_hashmacaddr_Policy>({}); }
+struct TArgs_hashmacaddrextended_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_has_column_privilege_id_id_attnum() { return &GenericExec<TPgDirectFunc<&has_column_privilege_id_id_attnum>, true, true, TArgs_has_column_privilege_id_id_attnum_Policy>; }
-struct TArgs_has_column_privilege_id_id_name_Policy {
+TExecFunc arrow_hashmacaddrextended() { return TGenericExec<TPgDirectFunc<&hashmacaddrextended>, true, true, TArgs_hashmacaddrextended_Policy>({}); }
+struct TArgs_i2tod_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_has_column_privilege_id_id_name() { return &GenericExec<TPgDirectFunc<&has_column_privilege_id_id_name>, true, true, TArgs_has_column_privilege_id_id_name_Policy>; }
-struct TArgs_has_column_privilege_id_name_Policy {
+TExecFunc arrow_i2tod() { return TGenericExec<TPgDirectFunc<&i2tod>, true, true, TArgs_i2tod_Policy>({}); }
+struct TArgs_i2tof_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_has_column_privilege_id_name() { return &GenericExec<TPgDirectFunc<&has_column_privilege_id_name>, true, true, TArgs_has_column_privilege_id_name_Policy>; }
-struct TArgs_has_column_privilege_id_name_attnum_Policy {
+TExecFunc arrow_i2tof() { return TGenericExec<TPgDirectFunc<&i2tof>, true, true, TArgs_i2tof_Policy>({}); }
+struct TArgs_i4tod_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,false,true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_has_column_privilege_id_name_attnum() { return &GenericExec<TPgDirectFunc<&has_column_privilege_id_name_attnum>, true, true, TArgs_has_column_privilege_id_name_attnum_Policy>; }
-struct TArgs_has_column_privilege_id_name_name_Policy {
+TExecFunc arrow_i4tod() { return TGenericExec<TPgDirectFunc<&i4tod>, true, true, TArgs_i4tod_Policy>({}); }
+struct TArgs_i4tof_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,false,false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_has_column_privilege_id_name_name() { return &GenericExec<TPgDirectFunc<&has_column_privilege_id_name_name>, true, true, TArgs_has_column_privilege_id_name_name_Policy>; }
-struct TArgs_has_column_privilege_name_attnum_Policy {
+TExecFunc arrow_i4tof() { return TGenericExec<TPgDirectFunc<&i4tof>, true, true, TArgs_i4tof_Policy>({}); }
+struct TArgs_in_range_float4_float8_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
 };
-TExecFunc arrow_has_column_privilege_name_attnum() { return &GenericExec<TPgDirectFunc<&has_column_privilege_name_attnum>, true, true, TArgs_has_column_privilege_name_attnum_Policy>; }
-struct TArgs_has_column_privilege_name_id_attnum_Policy {
+TExecFunc arrow_in_range_float4_float8() { return TGenericExec<TPgDirectFunc<&in_range_float4_float8>, true, true, TArgs_in_range_float4_float8_Policy>({}); }
+struct TArgs_in_range_float8_float8_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,true,true,false};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
 };
-TExecFunc arrow_has_column_privilege_name_id_attnum() { return &GenericExec<TPgDirectFunc<&has_column_privilege_name_id_attnum>, true, true, TArgs_has_column_privilege_name_id_attnum_Policy>; }
-struct TArgs_has_column_privilege_name_id_name_Policy {
+TExecFunc arrow_in_range_float8_float8() { return TGenericExec<TPgDirectFunc<&in_range_float8_float8>, true, true, TArgs_in_range_float8_float8_Policy>({}); }
+struct TArgs_index_am_handler_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,true,false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_has_column_privilege_name_id_name() { return &GenericExec<TPgDirectFunc<&has_column_privilege_name_id_name>, true, true, TArgs_has_column_privilege_name_id_name_Policy>; }
-struct TArgs_has_column_privilege_name_name_Policy {
+TExecFunc arrow_index_am_handler_in() { return TGenericExec<TPgDirectFunc<&index_am_handler_in>, false, true, TArgs_index_am_handler_in_Policy>({}); }
+struct TArgs_index_am_handler_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_has_column_privilege_name_name() { return &GenericExec<TPgDirectFunc<&has_column_privilege_name_name>, true, true, TArgs_has_column_privilege_name_name_Policy>; }
-struct TArgs_has_column_privilege_name_name_attnum_Policy {
+TExecFunc arrow_index_am_handler_out() { return TGenericExec<TPgDirectFunc<&index_am_handler_out>, true, false, TArgs_index_am_handler_out_Policy>({}); }
+struct TArgs_internal_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,false,true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_has_column_privilege_name_name_attnum() { return &GenericExec<TPgDirectFunc<&has_column_privilege_name_name_attnum>, true, true, TArgs_has_column_privilege_name_name_attnum_Policy>; }
-struct TArgs_has_column_privilege_name_name_name_Policy {
+TExecFunc arrow_internal_in() { return TGenericExec<TPgDirectFunc<&internal_in>, false, true, TArgs_internal_in_Policy>({}); }
+struct TArgs_internal_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_has_column_privilege_name_name_name() { return &GenericExec<TPgDirectFunc<&has_column_privilege_name_name_name>, true, true, TArgs_has_column_privilege_name_name_name_Policy>; }
-struct TArgs_has_database_privilege_id_Policy {
+TExecFunc arrow_internal_out() { return TGenericExec<TPgDirectFunc<&internal_out>, true, false, TArgs_internal_out_Policy>({}); }
+struct TArgs_language_handler_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_has_database_privilege_id() { return &GenericExec<TPgDirectFunc<&has_database_privilege_id>, true, true, TArgs_has_database_privilege_id_Policy>; }
-struct TArgs_has_database_privilege_id_id_Policy {
+TExecFunc arrow_language_handler_in() { return TGenericExec<TPgDirectFunc<&language_handler_in>, false, true, TArgs_language_handler_in_Policy>({}); }
+struct TArgs_language_handler_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_has_database_privilege_id_id() { return &GenericExec<TPgDirectFunc<&has_database_privilege_id_id>, true, true, TArgs_has_database_privilege_id_id_Policy>; }
-struct TArgs_has_database_privilege_id_name_Policy {
+TExecFunc arrow_language_handler_out() { return TGenericExec<TPgDirectFunc<&language_handler_out>, true, false, TArgs_language_handler_out_Policy>({}); }
+struct TArgs_lastval_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_has_database_privilege_id_name() { return &GenericExec<TPgDirectFunc<&has_database_privilege_id_name>, true, true, TArgs_has_database_privilege_id_name_Policy>; }
-struct TArgs_has_database_privilege_name_Policy {
+TExecFunc arrow_lastval() { return TGenericExec<TPgDirectFunc<&lastval>, true, true, TArgs_lastval_Policy>({}); }
+struct TArgs_macaddr_and_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_database_privilege_name() { return &GenericExec<TPgDirectFunc<&has_database_privilege_name>, true, true, TArgs_has_database_privilege_name_Policy>; }
-struct TArgs_has_database_privilege_name_id_Policy {
+TExecFunc arrow_macaddr_and() { return TGenericExec<TPgDirectFunc<&macaddr_and>, true, false, TArgs_macaddr_and_Policy>({}); }
+struct TArgs_macaddr_cmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_database_privilege_name_id() { return &GenericExec<TPgDirectFunc<&has_database_privilege_name_id>, true, true, TArgs_has_database_privilege_name_id_Policy>; }
-struct TArgs_has_database_privilege_name_name_Policy {
+TExecFunc arrow_macaddr_cmp() { return TGenericExec<TPgDirectFunc<&macaddr_cmp>, true, true, TArgs_macaddr_cmp_Policy>({}); }
+struct TArgs_macaddr_eq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_database_privilege_name_name() { return &GenericExec<TPgDirectFunc<&has_database_privilege_name_name>, true, true, TArgs_has_database_privilege_name_name_Policy>; }
-struct TArgs_has_foreign_data_wrapper_privilege_id_Policy {
+TExecFunc arrow_macaddr_eq() { return TGenericExec<TPgDirectFunc<&macaddr_eq>, true, true, TArgs_macaddr_eq_Policy>({}); }
+struct TArgs_macaddr_ge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_foreign_data_wrapper_privilege_id() { return &GenericExec<TPgDirectFunc<&has_foreign_data_wrapper_privilege_id>, true, true, TArgs_has_foreign_data_wrapper_privilege_id_Policy>; }
-struct TArgs_has_foreign_data_wrapper_privilege_id_id_Policy {
+TExecFunc arrow_macaddr_ge() { return TGenericExec<TPgDirectFunc<&macaddr_ge>, true, true, TArgs_macaddr_ge_Policy>({}); }
+struct TArgs_macaddr_gt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_foreign_data_wrapper_privilege_id_id() { return &GenericExec<TPgDirectFunc<&has_foreign_data_wrapper_privilege_id_id>, true, true, TArgs_has_foreign_data_wrapper_privilege_id_id_Policy>; }
-struct TArgs_has_foreign_data_wrapper_privilege_id_name_Policy {
+TExecFunc arrow_macaddr_gt() { return TGenericExec<TPgDirectFunc<&macaddr_gt>, true, true, TArgs_macaddr_gt_Policy>({}); }
+struct TArgs_macaddr_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_has_foreign_data_wrapper_privilege_id_name() { return &GenericExec<TPgDirectFunc<&has_foreign_data_wrapper_privilege_id_name>, true, true, TArgs_has_foreign_data_wrapper_privilege_id_name_Policy>; }
-struct TArgs_has_foreign_data_wrapper_privilege_name_Policy {
+TExecFunc arrow_macaddr_in() { return TGenericExec<TPgDirectFunc<&macaddr_in>, true, false, TArgs_macaddr_in_Policy>({}); }
+struct TArgs_macaddr_le_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_foreign_data_wrapper_privilege_name() { return &GenericExec<TPgDirectFunc<&has_foreign_data_wrapper_privilege_name>, true, true, TArgs_has_foreign_data_wrapper_privilege_name_Policy>; }
-struct TArgs_has_foreign_data_wrapper_privilege_name_id_Policy {
+TExecFunc arrow_macaddr_le() { return TGenericExec<TPgDirectFunc<&macaddr_le>, true, true, TArgs_macaddr_le_Policy>({}); }
+struct TArgs_macaddr_lt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_foreign_data_wrapper_privilege_name_id() { return &GenericExec<TPgDirectFunc<&has_foreign_data_wrapper_privilege_name_id>, true, true, TArgs_has_foreign_data_wrapper_privilege_name_id_Policy>; }
-struct TArgs_has_foreign_data_wrapper_privilege_name_name_Policy {
+TExecFunc arrow_macaddr_lt() { return TGenericExec<TPgDirectFunc<&macaddr_lt>, true, true, TArgs_macaddr_lt_Policy>({}); }
+struct TArgs_macaddr_ne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_foreign_data_wrapper_privilege_name_name() { return &GenericExec<TPgDirectFunc<&has_foreign_data_wrapper_privilege_name_name>, true, true, TArgs_has_foreign_data_wrapper_privilege_name_name_Policy>; }
-struct TArgs_has_function_privilege_id_Policy {
+TExecFunc arrow_macaddr_ne() { return TGenericExec<TPgDirectFunc<&macaddr_ne>, true, true, TArgs_macaddr_ne_Policy>({}); }
+struct TArgs_macaddr_not_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_has_function_privilege_id() { return &GenericExec<TPgDirectFunc<&has_function_privilege_id>, true, true, TArgs_has_function_privilege_id_Policy>; }
-struct TArgs_has_function_privilege_id_id_Policy {
+TExecFunc arrow_macaddr_not() { return TGenericExec<TPgDirectFunc<&macaddr_not>, true, false, TArgs_macaddr_not_Policy>({}); }
+struct TArgs_macaddr_or_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_function_privilege_id_id() { return &GenericExec<TPgDirectFunc<&has_function_privilege_id_id>, true, true, TArgs_has_function_privilege_id_id_Policy>; }
-struct TArgs_has_function_privilege_id_name_Policy {
+TExecFunc arrow_macaddr_or() { return TGenericExec<TPgDirectFunc<&macaddr_or>, true, false, TArgs_macaddr_or_Policy>({}); }
+struct TArgs_macaddr_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_has_function_privilege_id_name() { return &GenericExec<TPgDirectFunc<&has_function_privilege_id_name>, true, true, TArgs_has_function_privilege_id_name_Policy>; }
-struct TArgs_has_function_privilege_name_Policy {
+TExecFunc arrow_macaddr_out() { return TGenericExec<TPgDirectFunc<&macaddr_out>, true, false, TArgs_macaddr_out_Policy>({}); }
+struct TArgs_macaddr_recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_has_function_privilege_name() { return &GenericExec<TPgDirectFunc<&has_function_privilege_name>, true, true, TArgs_has_function_privilege_name_Policy>; }
-struct TArgs_has_function_privilege_name_id_Policy {
+TExecFunc arrow_macaddr_recv() { return TGenericExec<TPgDirectFunc<&macaddr_recv>, true, false, TArgs_macaddr_recv_Policy>({}); }
+struct TArgs_macaddr_send_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_has_function_privilege_name_id() { return &GenericExec<TPgDirectFunc<&has_function_privilege_name_id>, true, true, TArgs_has_function_privilege_name_id_Policy>; }
-struct TArgs_has_function_privilege_name_name_Policy {
+TExecFunc arrow_macaddr_send() { return TGenericExec<TPgDirectFunc<&macaddr_send>, true, false, TArgs_macaddr_send_Policy>({}); }
+struct TArgs_macaddr_sortsupport_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_has_function_privilege_name_name() { return &GenericExec<TPgDirectFunc<&has_function_privilege_name_name>, true, true, TArgs_has_function_privilege_name_name_Policy>; }
-struct TArgs_has_language_privilege_id_Policy {
+TExecFunc arrow_macaddr_sortsupport() { return TGenericExec<TPgDirectFunc<&macaddr_sortsupport>, true, true, TArgs_macaddr_sortsupport_Policy>({}); }
+struct TArgs_macaddr_trunc_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_has_language_privilege_id() { return &GenericExec<TPgDirectFunc<&has_language_privilege_id>, true, true, TArgs_has_language_privilege_id_Policy>; }
-struct TArgs_has_language_privilege_id_id_Policy {
+TExecFunc arrow_macaddr_trunc() { return TGenericExec<TPgDirectFunc<&macaddr_trunc>, true, false, TArgs_macaddr_trunc_Policy>({}); }
+struct TArgs_mode_final_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_has_language_privilege_id_id() { return &GenericExec<TPgDirectFunc<&has_language_privilege_id_id>, true, true, TArgs_has_language_privilege_id_id_Policy>; }
-struct TArgs_has_language_privilege_id_name_Policy {
+TExecFunc arrow_mode_final() { return TGenericExec<TPgDirectFunc<&mode_final>, false, true, TArgs_mode_final_Policy>({}); }
+struct TArgs_multirange_adjacent_multirange_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_language_privilege_id_name() { return &GenericExec<TPgDirectFunc<&has_language_privilege_id_name>, true, true, TArgs_has_language_privilege_id_name_Policy>; }
-struct TArgs_has_language_privilege_name_Policy {
+TExecFunc arrow_multirange_adjacent_multirange() { return TGenericExec<TPgDirectFunc<&multirange_adjacent_multirange>, true, true, TArgs_multirange_adjacent_multirange_Policy>({}); }
+struct TArgs_multirange_adjacent_range_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_language_privilege_name() { return &GenericExec<TPgDirectFunc<&has_language_privilege_name>, true, true, TArgs_has_language_privilege_name_Policy>; }
-struct TArgs_has_language_privilege_name_id_Policy {
+TExecFunc arrow_multirange_adjacent_range() { return TGenericExec<TPgDirectFunc<&multirange_adjacent_range>, true, true, TArgs_multirange_adjacent_range_Policy>({}); }
+struct TArgs_multirange_after_multirange_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_language_privilege_name_id() { return &GenericExec<TPgDirectFunc<&has_language_privilege_name_id>, true, true, TArgs_has_language_privilege_name_id_Policy>; }
-struct TArgs_has_language_privilege_name_name_Policy {
+TExecFunc arrow_multirange_after_multirange() { return TGenericExec<TPgDirectFunc<&multirange_after_multirange>, true, true, TArgs_multirange_after_multirange_Policy>({}); }
+struct TArgs_multirange_after_range_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_language_privilege_name_name() { return &GenericExec<TPgDirectFunc<&has_language_privilege_name_name>, true, true, TArgs_has_language_privilege_name_name_Policy>; }
-struct TArgs_has_schema_privilege_id_Policy {
+TExecFunc arrow_multirange_after_range() { return TGenericExec<TPgDirectFunc<&multirange_after_range>, true, true, TArgs_multirange_after_range_Policy>({}); }
+struct TArgs_multirange_before_multirange_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_schema_privilege_id() { return &GenericExec<TPgDirectFunc<&has_schema_privilege_id>, true, true, TArgs_has_schema_privilege_id_Policy>; }
-struct TArgs_has_schema_privilege_id_id_Policy {
+TExecFunc arrow_multirange_before_multirange() { return TGenericExec<TPgDirectFunc<&multirange_before_multirange>, true, true, TArgs_multirange_before_multirange_Policy>({}); }
+struct TArgs_multirange_before_range_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_schema_privilege_id_id() { return &GenericExec<TPgDirectFunc<&has_schema_privilege_id_id>, true, true, TArgs_has_schema_privilege_id_id_Policy>; }
-struct TArgs_has_schema_privilege_id_name_Policy {
+TExecFunc arrow_multirange_before_range() { return TGenericExec<TPgDirectFunc<&multirange_before_range>, true, true, TArgs_multirange_before_range_Policy>({}); }
+struct TArgs_multirange_cmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_schema_privilege_id_name() { return &GenericExec<TPgDirectFunc<&has_schema_privilege_id_name>, true, true, TArgs_has_schema_privilege_id_name_Policy>; }
-struct TArgs_has_schema_privilege_name_Policy {
+TExecFunc arrow_multirange_cmp() { return TGenericExec<TPgDirectFunc<&multirange_cmp>, true, true, TArgs_multirange_cmp_Policy>({}); }
+struct TArgs_multirange_constructor0_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_has_schema_privilege_name() { return &GenericExec<TPgDirectFunc<&has_schema_privilege_name>, true, true, TArgs_has_schema_privilege_name_Policy>; }
-struct TArgs_has_schema_privilege_name_id_Policy {
+TExecFunc arrow_multirange_constructor0() { return TGenericExec<TPgDirectFunc<&multirange_constructor0>, true, false, TArgs_multirange_constructor0_Policy>({}); }
+struct TArgs_multirange_constructor1_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_has_schema_privilege_name_id() { return &GenericExec<TPgDirectFunc<&has_schema_privilege_name_id>, true, true, TArgs_has_schema_privilege_name_id_Policy>; }
-struct TArgs_has_schema_privilege_name_name_Policy {
+TExecFunc arrow_multirange_constructor1() { return TGenericExec<TPgDirectFunc<&multirange_constructor1>, true, false, TArgs_multirange_constructor1_Policy>({}); }
+struct TArgs_multirange_contained_by_multirange_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_schema_privilege_name_name() { return &GenericExec<TPgDirectFunc<&has_schema_privilege_name_name>, true, true, TArgs_has_schema_privilege_name_name_Policy>; }
-struct TArgs_has_sequence_privilege_id_Policy {
+TExecFunc arrow_multirange_contained_by_multirange() { return TGenericExec<TPgDirectFunc<&multirange_contained_by_multirange>, true, true, TArgs_multirange_contained_by_multirange_Policy>({}); }
+struct TArgs_multirange_contained_by_range_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_sequence_privilege_id() { return &GenericExec<TPgDirectFunc<&has_sequence_privilege_id>, true, true, TArgs_has_sequence_privilege_id_Policy>; }
-struct TArgs_has_sequence_privilege_id_id_Policy {
+TExecFunc arrow_multirange_contained_by_range() { return TGenericExec<TPgDirectFunc<&multirange_contained_by_range>, true, true, TArgs_multirange_contained_by_range_Policy>({}); }
+struct TArgs_multirange_contains_elem_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_has_sequence_privilege_id_id() { return &GenericExec<TPgDirectFunc<&has_sequence_privilege_id_id>, true, true, TArgs_has_sequence_privilege_id_id_Policy>; }
-struct TArgs_has_sequence_privilege_id_name_Policy {
+TExecFunc arrow_multirange_contains_elem() { return TGenericExec<TPgDirectFunc<&multirange_contains_elem>, true, true, TArgs_multirange_contains_elem_Policy>({}); }
+struct TArgs_multirange_contains_multirange_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_sequence_privilege_id_name() { return &GenericExec<TPgDirectFunc<&has_sequence_privilege_id_name>, true, true, TArgs_has_sequence_privilege_id_name_Policy>; }
-struct TArgs_has_sequence_privilege_name_Policy {
+TExecFunc arrow_multirange_contains_multirange() { return TGenericExec<TPgDirectFunc<&multirange_contains_multirange>, true, true, TArgs_multirange_contains_multirange_Policy>({}); }
+struct TArgs_multirange_contains_range_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_sequence_privilege_name() { return &GenericExec<TPgDirectFunc<&has_sequence_privilege_name>, true, true, TArgs_has_sequence_privilege_name_Policy>; }
-struct TArgs_has_sequence_privilege_name_id_Policy {
+TExecFunc arrow_multirange_contains_range() { return TGenericExec<TPgDirectFunc<&multirange_contains_range>, true, true, TArgs_multirange_contains_range_Policy>({}); }
+struct TArgs_multirange_empty_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_has_sequence_privilege_name_id() { return &GenericExec<TPgDirectFunc<&has_sequence_privilege_name_id>, true, true, TArgs_has_sequence_privilege_name_id_Policy>; }
-struct TArgs_has_sequence_privilege_name_name_Policy {
+TExecFunc arrow_multirange_empty() { return TGenericExec<TPgDirectFunc<&multirange_empty>, true, true, TArgs_multirange_empty_Policy>({}); }
+struct TArgs_multirange_eq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_sequence_privilege_name_name() { return &GenericExec<TPgDirectFunc<&has_sequence_privilege_name_name>, true, true, TArgs_has_sequence_privilege_name_name_Policy>; }
-struct TArgs_has_server_privilege_id_Policy {
+TExecFunc arrow_multirange_eq() { return TGenericExec<TPgDirectFunc<&multirange_eq>, true, true, TArgs_multirange_eq_Policy>({}); }
+struct TArgs_multirange_ge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_server_privilege_id() { return &GenericExec<TPgDirectFunc<&has_server_privilege_id>, true, true, TArgs_has_server_privilege_id_Policy>; }
-struct TArgs_has_server_privilege_id_id_Policy {
+TExecFunc arrow_multirange_ge() { return TGenericExec<TPgDirectFunc<&multirange_ge>, true, true, TArgs_multirange_ge_Policy>({}); }
+struct TArgs_multirange_gt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_server_privilege_id_id() { return &GenericExec<TPgDirectFunc<&has_server_privilege_id_id>, true, true, TArgs_has_server_privilege_id_id_Policy>; }
-struct TArgs_has_server_privilege_id_name_Policy {
+TExecFunc arrow_multirange_gt() { return TGenericExec<TPgDirectFunc<&multirange_gt>, true, true, TArgs_multirange_gt_Policy>({}); }
+struct TArgs_multirange_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_has_server_privilege_id_name() { return &GenericExec<TPgDirectFunc<&has_server_privilege_id_name>, true, true, TArgs_has_server_privilege_id_name_Policy>; }
-struct TArgs_has_server_privilege_name_Policy {
+TExecFunc arrow_multirange_in() { return TGenericExec<TPgDirectFunc<&multirange_in>, true, false, TArgs_multirange_in_Policy>({}); }
+struct TArgs_multirange_intersect_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_server_privilege_name() { return &GenericExec<TPgDirectFunc<&has_server_privilege_name>, true, true, TArgs_has_server_privilege_name_Policy>; }
-struct TArgs_has_server_privilege_name_id_Policy {
+TExecFunc arrow_multirange_intersect() { return TGenericExec<TPgDirectFunc<&multirange_intersect>, true, false, TArgs_multirange_intersect_Policy>({}); }
+struct TArgs_multirange_intersect_agg_transfn_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_server_privilege_name_id() { return &GenericExec<TPgDirectFunc<&has_server_privilege_name_id>, true, true, TArgs_has_server_privilege_name_id_Policy>; }
-struct TArgs_has_server_privilege_name_name_Policy {
+TExecFunc arrow_multirange_intersect_agg_transfn() { return TGenericExec<TPgDirectFunc<&multirange_intersect_agg_transfn>, true, false, TArgs_multirange_intersect_agg_transfn_Policy>({}); }
+struct TArgs_multirange_le_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_server_privilege_name_name() { return &GenericExec<TPgDirectFunc<&has_server_privilege_name_name>, true, true, TArgs_has_server_privilege_name_name_Policy>; }
-struct TArgs_has_table_privilege_id_Policy {
+TExecFunc arrow_multirange_le() { return TGenericExec<TPgDirectFunc<&multirange_le>, true, true, TArgs_multirange_le_Policy>({}); }
+struct TArgs_multirange_lower_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_has_table_privilege_id() { return &GenericExec<TPgDirectFunc<&has_table_privilege_id>, true, true, TArgs_has_table_privilege_id_Policy>; }
-struct TArgs_has_table_privilege_id_id_Policy {
+TExecFunc arrow_multirange_lower() { return TGenericExec<TPgDirectFunc<&multirange_lower>, true, true, TArgs_multirange_lower_Policy>({}); }
+struct TArgs_multirange_lower_inc_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_has_table_privilege_id_id() { return &GenericExec<TPgDirectFunc<&has_table_privilege_id_id>, true, true, TArgs_has_table_privilege_id_id_Policy>; }
-struct TArgs_has_table_privilege_id_name_Policy {
+TExecFunc arrow_multirange_lower_inc() { return TGenericExec<TPgDirectFunc<&multirange_lower_inc>, true, true, TArgs_multirange_lower_inc_Policy>({}); }
+struct TArgs_multirange_lower_inf_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_has_table_privilege_id_name() { return &GenericExec<TPgDirectFunc<&has_table_privilege_id_name>, true, true, TArgs_has_table_privilege_id_name_Policy>; }
-struct TArgs_has_table_privilege_name_Policy {
+TExecFunc arrow_multirange_lower_inf() { return TGenericExec<TPgDirectFunc<&multirange_lower_inf>, true, true, TArgs_multirange_lower_inf_Policy>({}); }
+struct TArgs_multirange_lt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_table_privilege_name() { return &GenericExec<TPgDirectFunc<&has_table_privilege_name>, true, true, TArgs_has_table_privilege_name_Policy>; }
-struct TArgs_has_table_privilege_name_id_Policy {
+TExecFunc arrow_multirange_lt() { return TGenericExec<TPgDirectFunc<&multirange_lt>, true, true, TArgs_multirange_lt_Policy>({}); }
+struct TArgs_multirange_minus_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_table_privilege_name_id() { return &GenericExec<TPgDirectFunc<&has_table_privilege_name_id>, true, true, TArgs_has_table_privilege_name_id_Policy>; }
-struct TArgs_has_table_privilege_name_name_Policy {
+TExecFunc arrow_multirange_minus() { return TGenericExec<TPgDirectFunc<&multirange_minus>, true, false, TArgs_multirange_minus_Policy>({}); }
+struct TArgs_multirange_ne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_table_privilege_name_name() { return &GenericExec<TPgDirectFunc<&has_table_privilege_name_name>, true, true, TArgs_has_table_privilege_name_name_Policy>; }
-struct TArgs_has_tablespace_privilege_id_Policy {
+TExecFunc arrow_multirange_ne() { return TGenericExec<TPgDirectFunc<&multirange_ne>, true, true, TArgs_multirange_ne_Policy>({}); }
+struct TArgs_multirange_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_has_tablespace_privilege_id() { return &GenericExec<TPgDirectFunc<&has_tablespace_privilege_id>, true, true, TArgs_has_tablespace_privilege_id_Policy>; }
-struct TArgs_has_tablespace_privilege_id_id_Policy {
+TExecFunc arrow_multirange_out() { return TGenericExec<TPgDirectFunc<&multirange_out>, true, false, TArgs_multirange_out_Policy>({}); }
+struct TArgs_multirange_overlaps_multirange_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_tablespace_privilege_id_id() { return &GenericExec<TPgDirectFunc<&has_tablespace_privilege_id_id>, true, true, TArgs_has_tablespace_privilege_id_id_Policy>; }
-struct TArgs_has_tablespace_privilege_id_name_Policy {
+TExecFunc arrow_multirange_overlaps_multirange() { return TGenericExec<TPgDirectFunc<&multirange_overlaps_multirange>, true, true, TArgs_multirange_overlaps_multirange_Policy>({}); }
+struct TArgs_multirange_overlaps_range_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_tablespace_privilege_id_name() { return &GenericExec<TPgDirectFunc<&has_tablespace_privilege_id_name>, true, true, TArgs_has_tablespace_privilege_id_name_Policy>; }
-struct TArgs_has_tablespace_privilege_name_Policy {
+TExecFunc arrow_multirange_overlaps_range() { return TGenericExec<TPgDirectFunc<&multirange_overlaps_range>, true, true, TArgs_multirange_overlaps_range_Policy>({}); }
+struct TArgs_multirange_overleft_multirange_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_tablespace_privilege_name() { return &GenericExec<TPgDirectFunc<&has_tablespace_privilege_name>, true, true, TArgs_has_tablespace_privilege_name_Policy>; }
-struct TArgs_has_tablespace_privilege_name_id_Policy {
+TExecFunc arrow_multirange_overleft_multirange() { return TGenericExec<TPgDirectFunc<&multirange_overleft_multirange>, true, true, TArgs_multirange_overleft_multirange_Policy>({}); }
+struct TArgs_multirange_overleft_range_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_tablespace_privilege_name_id() { return &GenericExec<TPgDirectFunc<&has_tablespace_privilege_name_id>, true, true, TArgs_has_tablespace_privilege_name_id_Policy>; }
-struct TArgs_has_tablespace_privilege_name_name_Policy {
+TExecFunc arrow_multirange_overleft_range() { return TGenericExec<TPgDirectFunc<&multirange_overleft_range>, true, true, TArgs_multirange_overleft_range_Policy>({}); }
+struct TArgs_multirange_overright_multirange_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_tablespace_privilege_name_name() { return &GenericExec<TPgDirectFunc<&has_tablespace_privilege_name_name>, true, true, TArgs_has_tablespace_privilege_name_name_Policy>; }
-struct TArgs_has_type_privilege_id_Policy {
+TExecFunc arrow_multirange_overright_multirange() { return TGenericExec<TPgDirectFunc<&multirange_overright_multirange>, true, true, TArgs_multirange_overright_multirange_Policy>({}); }
+struct TArgs_multirange_overright_range_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_type_privilege_id() { return &GenericExec<TPgDirectFunc<&has_type_privilege_id>, true, true, TArgs_has_type_privilege_id_Policy>; }
-struct TArgs_has_type_privilege_id_id_Policy {
+TExecFunc arrow_multirange_overright_range() { return TGenericExec<TPgDirectFunc<&multirange_overright_range>, true, true, TArgs_multirange_overright_range_Policy>({}); }
+struct TArgs_multirange_recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_has_type_privilege_id_id() { return &GenericExec<TPgDirectFunc<&has_type_privilege_id_id>, true, true, TArgs_has_type_privilege_id_id_Policy>; }
-struct TArgs_has_type_privilege_id_name_Policy {
+TExecFunc arrow_multirange_recv() { return TGenericExec<TPgDirectFunc<&multirange_recv>, true, false, TArgs_multirange_recv_Policy>({}); }
+struct TArgs_multirange_send_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_has_type_privilege_id_name() { return &GenericExec<TPgDirectFunc<&has_type_privilege_id_name>, true, true, TArgs_has_type_privilege_id_name_Policy>; }
-struct TArgs_has_type_privilege_name_Policy {
+TExecFunc arrow_multirange_send() { return TGenericExec<TPgDirectFunc<&multirange_send>, true, false, TArgs_multirange_send_Policy>({}); }
+struct TArgs_multirange_union_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_has_type_privilege_name() { return &GenericExec<TPgDirectFunc<&has_type_privilege_name>, true, true, TArgs_has_type_privilege_name_Policy>; }
-struct TArgs_has_type_privilege_name_id_Policy {
+TExecFunc arrow_multirange_union() { return TGenericExec<TPgDirectFunc<&multirange_union>, true, false, TArgs_multirange_union_Policy>({}); }
+struct TArgs_multirange_upper_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_has_type_privilege_name_id() { return &GenericExec<TPgDirectFunc<&has_type_privilege_name_id>, true, true, TArgs_has_type_privilege_name_id_Policy>; }
-struct TArgs_has_type_privilege_name_name_Policy {
+TExecFunc arrow_multirange_upper() { return TGenericExec<TPgDirectFunc<&multirange_upper>, true, true, TArgs_multirange_upper_Policy>({}); }
+struct TArgs_multirange_upper_inc_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_has_type_privilege_name_name() { return &GenericExec<TPgDirectFunc<&has_type_privilege_name_name>, true, true, TArgs_has_type_privilege_name_name_Policy>; }
-struct TArgs_hash_aclitem_Policy {
+TExecFunc arrow_multirange_upper_inc() { return TGenericExec<TPgDirectFunc<&multirange_upper_inc>, true, true, TArgs_multirange_upper_inc_Policy>({}); }
+struct TArgs_multirange_upper_inf_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_hash_aclitem() { return &GenericExec<TPgDirectFunc<&hash_aclitem>, true, true, TArgs_hash_aclitem_Policy>; }
-struct TArgs_hash_aclitem_extended_Policy {
+TExecFunc arrow_multirange_upper_inf() { return TGenericExec<TPgDirectFunc<&multirange_upper_inf>, true, true, TArgs_multirange_upper_inf_Policy>({}); }
+struct TArgs_multirangesel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+};
+TExecFunc arrow_multirangesel() { return TGenericExec<TPgDirectFunc<&multirangesel>, true, true, TArgs_multirangesel_Policy>({}); }
+struct TArgs_mxid_age_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_hash_aclitem_extended() { return &GenericExec<TPgDirectFunc<&hash_aclitem_extended>, true, true, TArgs_hash_aclitem_extended_Policy>; }
-struct TArgs_hash_array_Policy {
+TExecFunc arrow_mxid_age() { return TGenericExec<TPgDirectFunc<&mxid_age>, true, true, TArgs_mxid_age_Policy>({}); }
+struct TArgs_name_bpchar_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_hash_array() { return &GenericExec<TPgDirectFunc<&hash_array>, true, true, TArgs_hash_array_Policy>; }
-struct TArgs_hash_array_extended_Policy {
+TExecFunc arrow_name_bpchar() { return TGenericExec<TPgDirectFunc<&name_bpchar>, true, false, TArgs_name_bpchar_Policy>({}); }
+struct TArgs_nameconcatoid_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_hash_array_extended() { return &GenericExec<TPgDirectFunc<&hash_array_extended>, true, true, TArgs_hash_array_extended_Policy>; }
-struct TArgs_hashbpchar_Policy {
+TExecFunc arrow_nameconcatoid() { return TGenericExec<TPgDirectFunc<&nameconcatoid>, true, false, TArgs_nameconcatoid_Policy>({}); }
+struct TArgs_nameeq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_hashbpchar() { return &GenericExec<TPgDirectFunc<&hashbpchar>, true, true, TArgs_hashbpchar_Policy>; }
-struct TArgs_hashbpcharextended_Policy {
+TExecFunc arrow_nameeq() { return TGenericExec<TPgDirectFunc<&nameeq>, true, true, TArgs_nameeq_Policy>({}); }
+struct TArgs_namege_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_hashbpcharextended() { return &GenericExec<TPgDirectFunc<&hashbpcharextended>, true, true, TArgs_hashbpcharextended_Policy>; }
-struct TArgs_hashchar_Policy {
+TExecFunc arrow_namege() { return TGenericExec<TPgDirectFunc<&namege>, true, true, TArgs_namege_Policy>({}); }
+struct TArgs_namegt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_hashchar() { return &GenericExec<TPgDirectFunc<&hashchar>, true, true, TArgs_hashchar_Policy>; }
-struct TArgs_hashcharextended_Policy {
+TExecFunc arrow_namegt() { return TGenericExec<TPgDirectFunc<&namegt>, true, true, TArgs_namegt_Policy>({}); }
+struct TArgs_namein_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_hashcharextended() { return &GenericExec<TPgDirectFunc<&hashcharextended>, true, true, TArgs_hashcharextended_Policy>; }
-struct TArgs_hashenum_Policy {
+TExecFunc arrow_namein() { return TGenericExec<TPgDirectFunc<&namein>, true, false, TArgs_namein_Policy>({}); }
+struct TArgs_namele_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_hashenum() { return &GenericExec<TPgDirectFunc<&hashenum>, true, true, TArgs_hashenum_Policy>; }
-struct TArgs_hashenumextended_Policy {
+TExecFunc arrow_namele() { return TGenericExec<TPgDirectFunc<&namele>, true, true, TArgs_namele_Policy>({}); }
+struct TArgs_namelt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_hashenumextended() { return &GenericExec<TPgDirectFunc<&hashenumextended>, true, true, TArgs_hashenumextended_Policy>; }
-struct TArgs_hashfloat4_Policy {
+TExecFunc arrow_namelt() { return TGenericExec<TPgDirectFunc<&namelt>, true, true, TArgs_namelt_Policy>({}); }
+struct TArgs_namene_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_hashfloat4() { return &GenericExec<TPgDirectFunc<&hashfloat4>, true, true, TArgs_hashfloat4_Policy>; }
-struct TArgs_hashfloat4extended_Policy {
+TExecFunc arrow_namene() { return TGenericExec<TPgDirectFunc<&namene>, true, true, TArgs_namene_Policy>({}); }
+struct TArgs_nameout_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_hashfloat4extended() { return &GenericExec<TPgDirectFunc<&hashfloat4extended>, true, true, TArgs_hashfloat4extended_Policy>; }
-struct TArgs_hashfloat8_Policy {
+TExecFunc arrow_nameout() { return TGenericExec<TPgDirectFunc<&nameout>, true, false, TArgs_nameout_Policy>({}); }
+struct TArgs_namerecv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_hashfloat8() { return &GenericExec<TPgDirectFunc<&hashfloat8>, true, true, TArgs_hashfloat8_Policy>; }
-struct TArgs_hashfloat8extended_Policy {
+TExecFunc arrow_namerecv() { return TGenericExec<TPgDirectFunc<&namerecv>, true, false, TArgs_namerecv_Policy>({}); }
+struct TArgs_namesend_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_hashfloat8extended() { return &GenericExec<TPgDirectFunc<&hashfloat8extended>, true, true, TArgs_hashfloat8extended_Policy>; }
-struct TArgs_hashinet_Policy {
+TExecFunc arrow_namesend() { return TGenericExec<TPgDirectFunc<&namesend>, true, false, TArgs_namesend_Policy>({}); }
+struct TArgs_networkjoinsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
 };
-TExecFunc arrow_hashinet() { return &GenericExec<TPgDirectFunc<&hashinet>, true, true, TArgs_hashinet_Policy>; }
-struct TArgs_hashinetextended_Policy {
+TExecFunc arrow_networkjoinsel() { return TGenericExec<TPgDirectFunc<&networkjoinsel>, true, true, TArgs_networkjoinsel_Policy>({}); }
+struct TArgs_networksel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_hashinetextended() { return &GenericExec<TPgDirectFunc<&hashinetextended>, true, true, TArgs_hashinetextended_Policy>; }
-struct TArgs_hashint2_Policy {
+TExecFunc arrow_networksel() { return TGenericExec<TPgDirectFunc<&networksel>, true, true, TArgs_networksel_Policy>({}); }
+struct TArgs_nextval_oid_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_hashint2() { return &GenericExec<TPgDirectFunc<&hashint2>, true, true, TArgs_hashint2_Policy>; }
-struct TArgs_hashint2extended_Policy {
+TExecFunc arrow_nextval_oid() { return TGenericExec<TPgDirectFunc<&nextval_oid>, true, true, TArgs_nextval_oid_Policy>({}); }
+struct TArgs_ordered_set_transition_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_hashint2extended() { return &GenericExec<TPgDirectFunc<&hashint2extended>, true, true, TArgs_hashint2extended_Policy>; }
-struct TArgs_hashint4_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_hashint4() { return &GenericExec<TPgDirectFunc<&hashint4>, true, true, TArgs_hashint4_Policy>; }
-struct TArgs_hashint4extended_Policy {
+TExecFunc arrow_ordered_set_transition() { return TGenericExec<TPgDirectFunc<&ordered_set_transition>, false, true, TArgs_ordered_set_transition_Policy>({}); }
+struct TArgs_percentile_cont_float8_final_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_hashint4extended() { return &GenericExec<TPgDirectFunc<&hashint4extended>, true, true, TArgs_hashint4extended_Policy>; }
-struct TArgs_hashint8_Policy {
+TExecFunc arrow_percentile_cont_float8_final() { return TGenericExec<TPgDirectFunc<&percentile_cont_float8_final>, false, true, TArgs_percentile_cont_float8_final_Policy>({}); }
+struct TArgs_percentile_cont_float8_multi_final_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_hashint8() { return &GenericExec<TPgDirectFunc<&hashint8>, true, true, TArgs_hashint8_Policy>; }
-struct TArgs_hashint8extended_Policy {
+TExecFunc arrow_percentile_cont_float8_multi_final() { return TGenericExec<TPgDirectFunc<&percentile_cont_float8_multi_final>, false, false, TArgs_percentile_cont_float8_multi_final_Policy>({}); }
+struct TArgs_percentile_cont_interval_final_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_hashint8extended() { return &GenericExec<TPgDirectFunc<&hashint8extended>, true, true, TArgs_hashint8extended_Policy>; }
-struct TArgs_hashname_Policy {
+TExecFunc arrow_percentile_cont_interval_final() { return TGenericExec<TPgDirectFunc<&percentile_cont_interval_final>, false, false, TArgs_percentile_cont_interval_final_Policy>({}); }
+struct TArgs_percentile_cont_interval_multi_final_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_hashname() { return &GenericExec<TPgDirectFunc<&hashname>, true, true, TArgs_hashname_Policy>; }
-struct TArgs_hashnameextended_Policy {
+TExecFunc arrow_percentile_cont_interval_multi_final() { return TGenericExec<TPgDirectFunc<&percentile_cont_interval_multi_final>, false, false, TArgs_percentile_cont_interval_multi_final_Policy>({}); }
+struct TArgs_percentile_disc_final_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_hashnameextended() { return &GenericExec<TPgDirectFunc<&hashnameextended>, true, true, TArgs_hashnameextended_Policy>; }
-struct TArgs_hashoid_Policy {
+TExecFunc arrow_percentile_disc_final() { return TGenericExec<TPgDirectFunc<&percentile_disc_final>, false, true, TArgs_percentile_disc_final_Policy>({}); }
+struct TArgs_percentile_disc_multi_final_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,false,true};
 };
-TExecFunc arrow_hashoid() { return &GenericExec<TPgDirectFunc<&hashoid>, true, true, TArgs_hashoid_Policy>; }
-struct TArgs_hashoidextended_Policy {
+TExecFunc arrow_percentile_disc_multi_final() { return TGenericExec<TPgDirectFunc<&percentile_disc_multi_final>, false, false, TArgs_percentile_disc_multi_final_Policy>({}); }
+struct TArgs_pg_backend_pid_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_hashoidextended() { return &GenericExec<TPgDirectFunc<&hashoidextended>, true, true, TArgs_hashoidextended_Policy>; }
-struct TArgs_hashoidvector_Policy {
+TExecFunc arrow_pg_backend_pid() { return TGenericExec<TPgDirectFunc<&pg_backend_pid>, true, true, TArgs_pg_backend_pid_Policy>({}); }
+struct TArgs_pg_backup_start_time_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_hashoidvector() { return &GenericExec<TPgDirectFunc<&hashoidvector>, true, true, TArgs_hashoidvector_Policy>; }
-struct TArgs_hashoidvectorextended_Policy {
+TExecFunc arrow_pg_backup_start_time() { return TGenericExec<TPgDirectFunc<&pg_backup_start_time>, true, true, TArgs_pg_backup_start_time_Policy>({}); }
+struct TArgs_pg_collation_is_visible_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_hashoidvectorextended() { return &GenericExec<TPgDirectFunc<&hashoidvectorextended>, true, true, TArgs_hashoidvectorextended_Policy>; }
-struct TArgs_hashtext_Policy {
+TExecFunc arrow_pg_collation_is_visible() { return TGenericExec<TPgDirectFunc<&pg_collation_is_visible>, true, true, TArgs_pg_collation_is_visible_Policy>({}); }
+struct TArgs_pg_control_checkpoint_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_hashtext() { return &GenericExec<TPgDirectFunc<&hashtext>, true, true, TArgs_hashtext_Policy>; }
-struct TArgs_hashtextextended_Policy {
+TExecFunc arrow_pg_control_checkpoint() { return TGenericExec<TPgDirectFunc<&pg_control_checkpoint>, true, false, TArgs_pg_control_checkpoint_Policy>({}); }
+struct TArgs_pg_control_init_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_hashtextextended() { return &GenericExec<TPgDirectFunc<&hashtextextended>, true, true, TArgs_hashtextextended_Policy>; }
-struct TArgs_hashvarlena_Policy {
+TExecFunc arrow_pg_control_init() { return TGenericExec<TPgDirectFunc<&pg_control_init>, true, false, TArgs_pg_control_init_Policy>({}); }
+struct TArgs_pg_control_recovery_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_hashvarlena() { return &GenericExec<TPgDirectFunc<&hashvarlena>, true, true, TArgs_hashvarlena_Policy>; }
-struct TArgs_hashvarlenaextended_Policy {
+TExecFunc arrow_pg_control_recovery() { return TGenericExec<TPgDirectFunc<&pg_control_recovery>, true, false, TArgs_pg_control_recovery_Policy>({}); }
+struct TArgs_pg_control_system_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_hashvarlenaextended() { return &GenericExec<TPgDirectFunc<&hashvarlenaextended>, true, true, TArgs_hashvarlenaextended_Policy>; }
-struct TArgs_heap_tableam_handler_Policy {
+TExecFunc arrow_pg_control_system() { return TGenericExec<TPgDirectFunc<&pg_control_system>, true, false, TArgs_pg_control_system_Policy>({}); }
+struct TArgs_pg_conversion_is_visible_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_heap_tableam_handler() { return &GenericExec<TPgDirectFunc<&heap_tableam_handler>, true, true, TArgs_heap_tableam_handler_Policy>; }
-struct TArgs_inet_abbrev_Policy {
+TExecFunc arrow_pg_conversion_is_visible() { return TGenericExec<TPgDirectFunc<&pg_conversion_is_visible>, true, true, TArgs_pg_conversion_is_visible_Policy>({}); }
+struct TArgs_pg_create_restore_point_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_inet_abbrev() { return &GenericExec<TPgDirectFunc<&inet_abbrev>, true, false, TArgs_inet_abbrev_Policy>; }
-struct TArgs_inet_client_addr_Policy {
+TExecFunc arrow_pg_create_restore_point() { return TGenericExec<TPgDirectFunc<&pg_create_restore_point>, true, true, TArgs_pg_create_restore_point_Policy>({}); }
+struct TArgs_pg_current_wal_flush_lsn_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_inet_client_addr() { return &GenericExec<TPgDirectFunc<&inet_client_addr>, false, false, TArgs_inet_client_addr_Policy>; }
-struct TArgs_inet_client_port_Policy {
+TExecFunc arrow_pg_current_wal_flush_lsn() { return TGenericExec<TPgDirectFunc<&pg_current_wal_flush_lsn>, true, true, TArgs_pg_current_wal_flush_lsn_Policy>({}); }
+struct TArgs_pg_current_wal_insert_lsn_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_inet_client_port() { return &GenericExec<TPgDirectFunc<&inet_client_port>, false, true, TArgs_inet_client_port_Policy>; }
-struct TArgs_inet_gist_compress_Policy {
+TExecFunc arrow_pg_current_wal_insert_lsn() { return TGenericExec<TPgDirectFunc<&pg_current_wal_insert_lsn>, true, true, TArgs_pg_current_wal_insert_lsn_Policy>({}); }
+struct TArgs_pg_current_wal_lsn_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_inet_gist_compress() { return &GenericExec<TPgDirectFunc<&inet_gist_compress>, true, true, TArgs_inet_gist_compress_Policy>; }
-struct TArgs_inet_gist_consistent_Policy {
+TExecFunc arrow_pg_current_wal_lsn() { return TGenericExec<TPgDirectFunc<&pg_current_wal_lsn>, true, true, TArgs_pg_current_wal_lsn_Policy>({}); }
+struct TArgs_pg_database_size_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,false,true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_inet_gist_consistent() { return &GenericExec<TPgDirectFunc<&inet_gist_consistent>, true, true, TArgs_inet_gist_consistent_Policy>; }
-struct TArgs_inet_gist_fetch_Policy {
+TExecFunc arrow_pg_database_size_name() { return TGenericExec<TPgDirectFunc<&pg_database_size_name>, true, true, TArgs_pg_database_size_name_Policy>({}); }
+struct TArgs_pg_database_size_oid_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_inet_gist_fetch() { return &GenericExec<TPgDirectFunc<&inet_gist_fetch>, true, true, TArgs_inet_gist_fetch_Policy>; }
-struct TArgs_inet_gist_penalty_Policy {
+TExecFunc arrow_pg_database_size_oid() { return TGenericExec<TPgDirectFunc<&pg_database_size_oid>, true, true, TArgs_pg_database_size_oid_Policy>({}); }
+struct TArgs_pg_ddl_command_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
-};
-TExecFunc arrow_inet_gist_penalty() { return &GenericExec<TPgDirectFunc<&inet_gist_penalty>, true, true, TArgs_inet_gist_penalty_Policy>; }
-struct TArgs_inet_gist_picksplit_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_inet_gist_picksplit() { return &GenericExec<TPgDirectFunc<&inet_gist_picksplit>, true, true, TArgs_inet_gist_picksplit_Policy>; }
-struct TArgs_inet_gist_same_Policy {
+TExecFunc arrow_pg_ddl_command_in() { return TGenericExec<TPgDirectFunc<&pg_ddl_command_in>, true, true, TArgs_pg_ddl_command_in_Policy>({}); }
+struct TArgs_pg_ddl_command_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_inet_gist_same() { return &GenericExec<TPgDirectFunc<&inet_gist_same>, true, true, TArgs_inet_gist_same_Policy>; }
-struct TArgs_inet_gist_union_Policy {
+TExecFunc arrow_pg_ddl_command_out() { return TGenericExec<TPgDirectFunc<&pg_ddl_command_out>, true, false, TArgs_pg_ddl_command_out_Policy>({}); }
+struct TArgs_pg_ddl_command_recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_inet_gist_union() { return &GenericExec<TPgDirectFunc<&inet_gist_union>, true, false, TArgs_inet_gist_union_Policy>; }
-struct TArgs_inet_in_Policy {
+TExecFunc arrow_pg_ddl_command_recv() { return TGenericExec<TPgDirectFunc<&pg_ddl_command_recv>, true, true, TArgs_pg_ddl_command_recv_Policy>({}); }
+struct TArgs_pg_ddl_command_send_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_inet_in() { return &GenericExec<TPgDirectFunc<&inet_in>, true, false, TArgs_inet_in_Policy>; }
-struct TArgs_inet_merge_Policy {
+TExecFunc arrow_pg_ddl_command_send() { return TGenericExec<TPgDirectFunc<&pg_ddl_command_send>, true, false, TArgs_pg_ddl_command_send_Policy>({}); }
+struct TArgs_pg_extension_config_dump_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_inet_merge() { return &GenericExec<TPgDirectFunc<&inet_merge>, true, false, TArgs_inet_merge_Policy>; }
-struct TArgs_inet_out_Policy {
+TExecFunc arrow_pg_extension_config_dump() { return TGenericExec<TPgDirectFunc<&pg_extension_config_dump>, true, true, TArgs_pg_extension_config_dump_Policy>({}); }
+struct TArgs_pg_filenode_relation_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_inet_out() { return &GenericExec<TPgDirectFunc<&inet_out>, true, false, TArgs_inet_out_Policy>; }
-struct TArgs_inet_recv_Policy {
+TExecFunc arrow_pg_filenode_relation() { return TGenericExec<TPgDirectFunc<&pg_filenode_relation>, true, true, TArgs_pg_filenode_relation_Policy>({}); }
+struct TArgs_pg_function_is_visible_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_inet_recv() { return &GenericExec<TPgDirectFunc<&inet_recv>, true, false, TArgs_inet_recv_Policy>; }
-struct TArgs_inet_same_family_Policy {
+TExecFunc arrow_pg_function_is_visible() { return TGenericExec<TPgDirectFunc<&pg_function_is_visible>, true, true, TArgs_pg_function_is_visible_Policy>({}); }
+struct TArgs_pg_get_constraintdef_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_inet_same_family() { return &GenericExec<TPgDirectFunc<&inet_same_family>, true, true, TArgs_inet_same_family_Policy>; }
-struct TArgs_inet_send_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_inet_send() { return &GenericExec<TPgDirectFunc<&inet_send>, true, false, TArgs_inet_send_Policy>; }
-struct TArgs_inet_server_addr_Policy {
+TExecFunc arrow_pg_get_constraintdef() { return TGenericExec<TPgDirectFunc<&pg_get_constraintdef>, true, false, TArgs_pg_get_constraintdef_Policy>({}); }
+struct TArgs_pg_get_constraintdef_ext_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_inet_server_addr() { return &GenericExec<TPgDirectFunc<&inet_server_addr>, false, false, TArgs_inet_server_addr_Policy>; }
-struct TArgs_inet_server_port_Policy {
+TExecFunc arrow_pg_get_constraintdef_ext() { return TGenericExec<TPgDirectFunc<&pg_get_constraintdef_ext>, true, false, TArgs_pg_get_constraintdef_ext_Policy>({}); }
+struct TArgs_pg_get_expr_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_inet_server_port() { return &GenericExec<TPgDirectFunc<&inet_server_port>, false, true, TArgs_inet_server_port_Policy>; }
-struct TArgs_inet_set_masklen_Policy {
+TExecFunc arrow_pg_get_expr() { return TGenericExec<TPgDirectFunc<&pg_get_expr>, true, false, TArgs_pg_get_expr_Policy>({}); }
+struct TArgs_pg_get_expr_ext_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_inet_set_masklen() { return &GenericExec<TPgDirectFunc<&inet_set_masklen>, true, false, TArgs_inet_set_masklen_Policy>; }
-struct TArgs_inet_spg_choose_Policy {
+TExecFunc arrow_pg_get_expr_ext() { return TGenericExec<TPgDirectFunc<&pg_get_expr_ext>, true, false, TArgs_pg_get_expr_ext_Policy>({}); }
+struct TArgs_pg_get_function_arg_default_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_inet_spg_choose() { return &GenericExec<TPgDirectFunc<&inet_spg_choose>, true, true, TArgs_inet_spg_choose_Policy>; }
-struct TArgs_inet_spg_config_Policy {
+TExecFunc arrow_pg_get_function_arg_default() { return TGenericExec<TPgDirectFunc<&pg_get_function_arg_default>, true, false, TArgs_pg_get_function_arg_default_Policy>({}); }
+struct TArgs_pg_get_function_arguments_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_inet_spg_config() { return &GenericExec<TPgDirectFunc<&inet_spg_config>, true, true, TArgs_inet_spg_config_Policy>; }
-struct TArgs_inet_spg_inner_consistent_Policy {
+TExecFunc arrow_pg_get_function_arguments() { return TGenericExec<TPgDirectFunc<&pg_get_function_arguments>, true, false, TArgs_pg_get_function_arguments_Policy>({}); }
+struct TArgs_pg_get_function_identity_arguments_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_inet_spg_inner_consistent() { return &GenericExec<TPgDirectFunc<&inet_spg_inner_consistent>, true, true, TArgs_inet_spg_inner_consistent_Policy>; }
-struct TArgs_inet_spg_leaf_consistent_Policy {
+TExecFunc arrow_pg_get_function_identity_arguments() { return TGenericExec<TPgDirectFunc<&pg_get_function_identity_arguments>, true, false, TArgs_pg_get_function_identity_arguments_Policy>({}); }
+struct TArgs_pg_get_function_result_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_inet_spg_leaf_consistent() { return &GenericExec<TPgDirectFunc<&inet_spg_leaf_consistent>, true, true, TArgs_inet_spg_leaf_consistent_Policy>; }
-struct TArgs_inet_spg_picksplit_Policy {
+TExecFunc arrow_pg_get_function_result() { return TGenericExec<TPgDirectFunc<&pg_get_function_result>, true, false, TArgs_pg_get_function_result_Policy>({}); }
+struct TArgs_pg_get_function_sqlbody_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_inet_spg_picksplit() { return &GenericExec<TPgDirectFunc<&inet_spg_picksplit>, true, true, TArgs_inet_spg_picksplit_Policy>; }
-struct TArgs_inet_to_cidr_Policy {
+TExecFunc arrow_pg_get_function_sqlbody() { return TGenericExec<TPgDirectFunc<&pg_get_function_sqlbody>, true, false, TArgs_pg_get_function_sqlbody_Policy>({}); }
+struct TArgs_pg_get_functiondef_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_inet_to_cidr() { return &GenericExec<TPgDirectFunc<&inet_to_cidr>, true, false, TArgs_inet_to_cidr_Policy>; }
-struct TArgs_inetand_Policy {
+TExecFunc arrow_pg_get_functiondef() { return TGenericExec<TPgDirectFunc<&pg_get_functiondef>, true, false, TArgs_pg_get_functiondef_Policy>({}); }
+struct TArgs_pg_get_indexdef_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_inetand() { return &GenericExec<TPgDirectFunc<&inetand>, true, false, TArgs_inetand_Policy>; }
-struct TArgs_inetmi_Policy {
+TExecFunc arrow_pg_get_indexdef() { return TGenericExec<TPgDirectFunc<&pg_get_indexdef>, true, false, TArgs_pg_get_indexdef_Policy>({}); }
+struct TArgs_pg_get_indexdef_ext_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_inetmi() { return &GenericExec<TPgDirectFunc<&inetmi>, true, true, TArgs_inetmi_Policy>; }
-struct TArgs_inetmi_int8_Policy {
+TExecFunc arrow_pg_get_indexdef_ext() { return TGenericExec<TPgDirectFunc<&pg_get_indexdef_ext>, true, false, TArgs_pg_get_indexdef_ext_Policy>({}); }
+struct TArgs_pg_get_partition_constraintdef_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_inetmi_int8() { return &GenericExec<TPgDirectFunc<&inetmi_int8>, true, false, TArgs_inetmi_int8_Policy>; }
-struct TArgs_inetnot_Policy {
+TExecFunc arrow_pg_get_partition_constraintdef() { return TGenericExec<TPgDirectFunc<&pg_get_partition_constraintdef>, true, false, TArgs_pg_get_partition_constraintdef_Policy>({}); }
+struct TArgs_pg_get_partkeydef_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_inetnot() { return &GenericExec<TPgDirectFunc<&inetnot>, true, false, TArgs_inetnot_Policy>; }
-struct TArgs_inetor_Policy {
+TExecFunc arrow_pg_get_partkeydef() { return TGenericExec<TPgDirectFunc<&pg_get_partkeydef>, true, false, TArgs_pg_get_partkeydef_Policy>({}); }
+struct TArgs_pg_get_ruledef_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_inetor() { return &GenericExec<TPgDirectFunc<&inetor>, true, false, TArgs_inetor_Policy>; }
-struct TArgs_inetpl_Policy {
+TExecFunc arrow_pg_get_ruledef() { return TGenericExec<TPgDirectFunc<&pg_get_ruledef>, true, false, TArgs_pg_get_ruledef_Policy>({}); }
+struct TArgs_pg_get_ruledef_ext_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_inetpl() { return &GenericExec<TPgDirectFunc<&inetpl>, true, false, TArgs_inetpl_Policy>; }
-struct TArgs_initcap_Policy {
+TExecFunc arrow_pg_get_ruledef_ext() { return TGenericExec<TPgDirectFunc<&pg_get_ruledef_ext>, true, false, TArgs_pg_get_ruledef_ext_Policy>({}); }
+struct TArgs_pg_get_serial_sequence_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_initcap() { return &GenericExec<TPgDirectFunc<&initcap>, true, false, TArgs_initcap_Policy>; }
-struct TArgs_int4_to_char_Policy {
+TExecFunc arrow_pg_get_serial_sequence() { return TGenericExec<TPgDirectFunc<&pg_get_serial_sequence>, true, false, TArgs_pg_get_serial_sequence_Policy>({}); }
+struct TArgs_pg_get_statisticsobjdef_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int4_to_char() { return &GenericExec<TPgDirectFunc<&int4_to_char>, true, false, TArgs_int4_to_char_Policy>; }
-struct TArgs_int8_to_char_Policy {
+TExecFunc arrow_pg_get_statisticsobjdef() { return TGenericExec<TPgDirectFunc<&pg_get_statisticsobjdef>, true, false, TArgs_pg_get_statisticsobjdef_Policy>({}); }
+struct TArgs_pg_get_statisticsobjdef_columns_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_int8_to_char() { return &GenericExec<TPgDirectFunc<&int8_to_char>, true, false, TArgs_int8_to_char_Policy>; }
-struct TArgs_inter_lb_Policy {
+TExecFunc arrow_pg_get_statisticsobjdef_columns() { return TGenericExec<TPgDirectFunc<&pg_get_statisticsobjdef_columns>, true, false, TArgs_pg_get_statisticsobjdef_columns_Policy>({}); }
+struct TArgs_pg_get_statisticsobjdef_expressions_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_inter_lb() { return &GenericExec<TPgDirectFunc<&inter_lb>, true, true, TArgs_inter_lb_Policy>; }
-struct TArgs_inter_sb_Policy {
+TExecFunc arrow_pg_get_statisticsobjdef_expressions() { return TGenericExec<TPgDirectFunc<&pg_get_statisticsobjdef_expressions>, true, false, TArgs_pg_get_statisticsobjdef_expressions_Policy>({}); }
+struct TArgs_pg_get_triggerdef_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_inter_sb() { return &GenericExec<TPgDirectFunc<&inter_sb>, true, true, TArgs_inter_sb_Policy>; }
-struct TArgs_inter_sl_Policy {
+TExecFunc arrow_pg_get_triggerdef() { return TGenericExec<TPgDirectFunc<&pg_get_triggerdef>, true, false, TArgs_pg_get_triggerdef_Policy>({}); }
+struct TArgs_pg_get_triggerdef_ext_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_inter_sl() { return &GenericExec<TPgDirectFunc<&inter_sl>, true, true, TArgs_inter_sl_Policy>; }
-struct TArgs_interval_to_char_Policy {
+TExecFunc arrow_pg_get_triggerdef_ext() { return TGenericExec<TPgDirectFunc<&pg_get_triggerdef_ext>, true, false, TArgs_pg_get_triggerdef_ext_Policy>({}); }
+struct TArgs_pg_get_userbyid_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_interval_to_char() { return &GenericExec<TPgDirectFunc<&interval_to_char>, true, false, TArgs_interval_to_char_Policy>; }
-struct TArgs_json_agg_finalfn_Policy {
+TExecFunc arrow_pg_get_userbyid() { return TGenericExec<TPgDirectFunc<&pg_get_userbyid>, true, false, TArgs_pg_get_userbyid_Policy>({}); }
+struct TArgs_pg_get_viewdef_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_json_agg_finalfn() { return &GenericExec<TPgDirectFunc<&json_agg_finalfn>, false, false, TArgs_json_agg_finalfn_Policy>; }
-struct TArgs_json_agg_transfn_Policy {
+TExecFunc arrow_pg_get_viewdef() { return TGenericExec<TPgDirectFunc<&pg_get_viewdef>, true, false, TArgs_pg_get_viewdef_Policy>({}); }
+struct TArgs_pg_get_viewdef_ext_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_json_agg_transfn() { return &GenericExec<TPgDirectFunc<&json_agg_transfn>, false, true, TArgs_json_agg_transfn_Policy>; }
-struct TArgs_json_build_array_noargs_Policy {
+TExecFunc arrow_pg_get_viewdef_ext() { return TGenericExec<TPgDirectFunc<&pg_get_viewdef_ext>, true, false, TArgs_pg_get_viewdef_ext_Policy>({}); }
+struct TArgs_pg_get_viewdef_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_json_build_array_noargs() { return &GenericExec<TPgDirectFunc<&json_build_array_noargs>, false, false, TArgs_json_build_array_noargs_Policy>; }
-struct TArgs_json_build_object_noargs_Policy {
+TExecFunc arrow_pg_get_viewdef_name() { return TGenericExec<TPgDirectFunc<&pg_get_viewdef_name>, true, false, TArgs_pg_get_viewdef_name_Policy>({}); }
+struct TArgs_pg_get_viewdef_name_ext_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_json_build_object_noargs() { return &GenericExec<TPgDirectFunc<&json_build_object_noargs>, false, false, TArgs_json_build_object_noargs_Policy>; }
-struct TArgs_json_in_Policy {
+TExecFunc arrow_pg_get_viewdef_name_ext() { return TGenericExec<TPgDirectFunc<&pg_get_viewdef_name_ext>, true, false, TArgs_pg_get_viewdef_name_ext_Policy>({}); }
+struct TArgs_pg_get_viewdef_wrap_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_json_in() { return &GenericExec<TPgDirectFunc<&json_in>, true, false, TArgs_json_in_Policy>; }
-struct TArgs_json_object_Policy {
+TExecFunc arrow_pg_get_viewdef_wrap() { return TGenericExec<TPgDirectFunc<&pg_get_viewdef_wrap>, true, false, TArgs_pg_get_viewdef_wrap_Policy>({}); }
+struct TArgs_pg_get_wal_replay_pause_state_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_json_object() { return &GenericExec<TPgDirectFunc<&json_object>, true, false, TArgs_json_object_Policy>; }
-struct TArgs_json_object_agg_finalfn_Policy {
+TExecFunc arrow_pg_get_wal_replay_pause_state() { return TGenericExec<TPgDirectFunc<&pg_get_wal_replay_pause_state>, true, false, TArgs_pg_get_wal_replay_pause_state_Policy>({}); }
+struct TArgs_pg_index_column_has_property_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
 };
-TExecFunc arrow_json_object_agg_finalfn() { return &GenericExec<TPgDirectFunc<&json_object_agg_finalfn>, false, false, TArgs_json_object_agg_finalfn_Policy>; }
-struct TArgs_json_object_agg_transfn_Policy {
+TExecFunc arrow_pg_index_column_has_property() { return TGenericExec<TPgDirectFunc<&pg_index_column_has_property>, true, true, TArgs_pg_index_column_has_property_Policy>({}); }
+struct TArgs_pg_index_has_property_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_json_object_agg_transfn() { return &GenericExec<TPgDirectFunc<&json_object_agg_transfn>, false, true, TArgs_json_object_agg_transfn_Policy>; }
-struct TArgs_json_object_two_arg_Policy {
+TExecFunc arrow_pg_index_has_property() { return TGenericExec<TPgDirectFunc<&pg_index_has_property>, true, true, TArgs_pg_index_has_property_Policy>({}); }
+struct TArgs_pg_indexam_has_property_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_json_object_two_arg() { return &GenericExec<TPgDirectFunc<&json_object_two_arg>, true, false, TArgs_json_object_two_arg_Policy>; }
-struct TArgs_json_out_Policy {
+TExecFunc arrow_pg_indexam_has_property() { return TGenericExec<TPgDirectFunc<&pg_indexam_has_property>, true, true, TArgs_pg_indexam_has_property_Policy>({}); }
+struct TArgs_pg_indexam_progress_phasename_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_json_out() { return &GenericExec<TPgDirectFunc<&json_out>, true, false, TArgs_json_out_Policy>; }
-struct TArgs_json_recv_Policy {
+TExecFunc arrow_pg_indexam_progress_phasename() { return TGenericExec<TPgDirectFunc<&pg_indexam_progress_phasename>, true, false, TArgs_pg_indexam_progress_phasename_Policy>({}); }
+struct TArgs_pg_indexes_size_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_json_recv() { return &GenericExec<TPgDirectFunc<&json_recv>, true, false, TArgs_json_recv_Policy>; }
-struct TArgs_json_send_Policy {
+TExecFunc arrow_pg_indexes_size() { return TGenericExec<TPgDirectFunc<&pg_indexes_size>, true, true, TArgs_pg_indexes_size_Policy>({}); }
+struct TArgs_pg_is_in_backup_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_json_send() { return &GenericExec<TPgDirectFunc<&json_send>, true, false, TArgs_json_send_Policy>; }
-struct TArgs_json_typeof_Policy {
+TExecFunc arrow_pg_is_in_backup() { return TGenericExec<TPgDirectFunc<&pg_is_in_backup>, true, true, TArgs_pg_is_in_backup_Policy>({}); }
+struct TArgs_pg_is_in_recovery_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_json_typeof() { return &GenericExec<TPgDirectFunc<&json_typeof>, true, false, TArgs_json_typeof_Policy>; }
-struct TArgs_jsonb_agg_finalfn_Policy {
+TExecFunc arrow_pg_is_in_recovery() { return TGenericExec<TPgDirectFunc<&pg_is_in_recovery>, true, true, TArgs_pg_is_in_recovery_Policy>({}); }
+struct TArgs_pg_is_other_temp_schema_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_jsonb_agg_finalfn() { return &GenericExec<TPgDirectFunc<&jsonb_agg_finalfn>, false, false, TArgs_jsonb_agg_finalfn_Policy>; }
-struct TArgs_jsonb_agg_transfn_Policy {
+TExecFunc arrow_pg_is_other_temp_schema() { return TGenericExec<TPgDirectFunc<&pg_is_other_temp_schema>, true, true, TArgs_pg_is_other_temp_schema_Policy>({}); }
+struct TArgs_pg_is_wal_replay_paused_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_jsonb_agg_transfn() { return &GenericExec<TPgDirectFunc<&jsonb_agg_transfn>, false, true, TArgs_jsonb_agg_transfn_Policy>; }
-struct TArgs_jsonb_bool_Policy {
+TExecFunc arrow_pg_is_wal_replay_paused() { return TGenericExec<TPgDirectFunc<&pg_is_wal_replay_paused>, true, true, TArgs_pg_is_wal_replay_paused_Policy>({}); }
+struct TArgs_pg_jit_available_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_jsonb_bool() { return &GenericExec<TPgDirectFunc<&jsonb_bool>, true, true, TArgs_jsonb_bool_Policy>; }
-struct TArgs_jsonb_build_array_noargs_Policy {
+TExecFunc arrow_pg_jit_available() { return TGenericExec<TPgDirectFunc<&pg_jit_available>, true, true, TArgs_pg_jit_available_Policy>({}); }
+struct TArgs_pg_last_wal_receive_lsn_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_jsonb_build_array_noargs() { return &GenericExec<TPgDirectFunc<&jsonb_build_array_noargs>, false, false, TArgs_jsonb_build_array_noargs_Policy>; }
-struct TArgs_jsonb_build_object_noargs_Policy {
+TExecFunc arrow_pg_last_wal_receive_lsn() { return TGenericExec<TPgDirectFunc<&pg_last_wal_receive_lsn>, true, true, TArgs_pg_last_wal_receive_lsn_Policy>({}); }
+struct TArgs_pg_last_wal_replay_lsn_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_jsonb_build_object_noargs() { return &GenericExec<TPgDirectFunc<&jsonb_build_object_noargs>, false, false, TArgs_jsonb_build_object_noargs_Policy>; }
-struct TArgs_jsonb_float4_Policy {
+TExecFunc arrow_pg_last_wal_replay_lsn() { return TGenericExec<TPgDirectFunc<&pg_last_wal_replay_lsn>, true, true, TArgs_pg_last_wal_replay_lsn_Policy>({}); }
+struct TArgs_pg_last_xact_replay_timestamp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_jsonb_float4() { return &GenericExec<TPgDirectFunc<&jsonb_float4>, true, true, TArgs_jsonb_float4_Policy>; }
-struct TArgs_jsonb_float8_Policy {
+TExecFunc arrow_pg_last_xact_replay_timestamp() { return TGenericExec<TPgDirectFunc<&pg_last_xact_replay_timestamp>, true, true, TArgs_pg_last_xact_replay_timestamp_Policy>({}); }
+struct TArgs_pg_lsn_cmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_jsonb_float8() { return &GenericExec<TPgDirectFunc<&jsonb_float8>, true, true, TArgs_jsonb_float8_Policy>; }
-struct TArgs_jsonb_in_Policy {
+TExecFunc arrow_pg_lsn_cmp() { return TGenericExec<TPgDirectFunc<&pg_lsn_cmp>, true, true, TArgs_pg_lsn_cmp_Policy>({}); }
+struct TArgs_pg_lsn_eq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_jsonb_in() { return &GenericExec<TPgDirectFunc<&jsonb_in>, true, false, TArgs_jsonb_in_Policy>; }
-struct TArgs_jsonb_int2_Policy {
+TExecFunc arrow_pg_lsn_eq() { return TGenericExec<TPgDirectFunc<&pg_lsn_eq>, true, true, TArgs_pg_lsn_eq_Policy>({}); }
+struct TArgs_pg_lsn_ge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_jsonb_int2() { return &GenericExec<TPgDirectFunc<&jsonb_int2>, true, true, TArgs_jsonb_int2_Policy>; }
-struct TArgs_jsonb_int4_Policy {
+TExecFunc arrow_pg_lsn_ge() { return TGenericExec<TPgDirectFunc<&pg_lsn_ge>, true, true, TArgs_pg_lsn_ge_Policy>({}); }
+struct TArgs_pg_lsn_gt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_jsonb_int4() { return &GenericExec<TPgDirectFunc<&jsonb_int4>, true, true, TArgs_jsonb_int4_Policy>; }
-struct TArgs_jsonb_int8_Policy {
+TExecFunc arrow_pg_lsn_gt() { return TGenericExec<TPgDirectFunc<&pg_lsn_gt>, true, true, TArgs_pg_lsn_gt_Policy>({}); }
+struct TArgs_pg_lsn_hash_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_jsonb_int8() { return &GenericExec<TPgDirectFunc<&jsonb_int8>, true, true, TArgs_jsonb_int8_Policy>; }
-struct TArgs_jsonb_numeric_Policy {
+TExecFunc arrow_pg_lsn_hash() { return TGenericExec<TPgDirectFunc<&pg_lsn_hash>, true, true, TArgs_pg_lsn_hash_Policy>({}); }
+struct TArgs_pg_lsn_hash_extended_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_jsonb_numeric() { return &GenericExec<TPgDirectFunc<&jsonb_numeric>, true, false, TArgs_jsonb_numeric_Policy>; }
-struct TArgs_jsonb_object_Policy {
+TExecFunc arrow_pg_lsn_hash_extended() { return TGenericExec<TPgDirectFunc<&pg_lsn_hash_extended>, true, true, TArgs_pg_lsn_hash_extended_Policy>({}); }
+struct TArgs_pg_lsn_in_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_jsonb_object() { return &GenericExec<TPgDirectFunc<&jsonb_object>, true, false, TArgs_jsonb_object_Policy>; }
-struct TArgs_jsonb_object_agg_finalfn_Policy {
+TExecFunc arrow_pg_lsn_in() { return TGenericExec<TPgDirectFunc<&pg_lsn_in>, true, true, TArgs_pg_lsn_in_Policy>({}); }
+struct TArgs_pg_lsn_larger_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_jsonb_object_agg_finalfn() { return &GenericExec<TPgDirectFunc<&jsonb_object_agg_finalfn>, false, false, TArgs_jsonb_object_agg_finalfn_Policy>; }
-struct TArgs_jsonb_object_agg_transfn_Policy {
+TExecFunc arrow_pg_lsn_larger() { return TGenericExec<TPgDirectFunc<&pg_lsn_larger>, true, true, TArgs_pg_lsn_larger_Policy>({}); }
+struct TArgs_pg_lsn_le_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_jsonb_object_agg_transfn() { return &GenericExec<TPgDirectFunc<&jsonb_object_agg_transfn>, false, true, TArgs_jsonb_object_agg_transfn_Policy>; }
-struct TArgs_jsonb_object_two_arg_Policy {
+TExecFunc arrow_pg_lsn_le() { return TGenericExec<TPgDirectFunc<&pg_lsn_le>, true, true, TArgs_pg_lsn_le_Policy>({}); }
+struct TArgs_pg_lsn_lt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_jsonb_object_two_arg() { return &GenericExec<TPgDirectFunc<&jsonb_object_two_arg>, true, false, TArgs_jsonb_object_two_arg_Policy>; }
-struct TArgs_jsonb_out_Policy {
+TExecFunc arrow_pg_lsn_lt() { return TGenericExec<TPgDirectFunc<&pg_lsn_lt>, true, true, TArgs_pg_lsn_lt_Policy>({}); }
+struct TArgs_pg_lsn_mi_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_jsonb_out() { return &GenericExec<TPgDirectFunc<&jsonb_out>, true, false, TArgs_jsonb_out_Policy>; }
-struct TArgs_jsonb_recv_Policy {
+TExecFunc arrow_pg_lsn_mi() { return TGenericExec<TPgDirectFunc<&pg_lsn_mi>, true, false, TArgs_pg_lsn_mi_Policy>({}); }
+struct TArgs_pg_lsn_mii_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_jsonb_recv() { return &GenericExec<TPgDirectFunc<&jsonb_recv>, true, false, TArgs_jsonb_recv_Policy>; }
-struct TArgs_jsonb_send_Policy {
+TExecFunc arrow_pg_lsn_mii() { return TGenericExec<TPgDirectFunc<&pg_lsn_mii>, true, true, TArgs_pg_lsn_mii_Policy>({}); }
+struct TArgs_pg_lsn_ne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_jsonb_send() { return &GenericExec<TPgDirectFunc<&jsonb_send>, true, false, TArgs_jsonb_send_Policy>; }
-struct TArgs_jsonb_subscript_handler_Policy {
+TExecFunc arrow_pg_lsn_ne() { return TGenericExec<TPgDirectFunc<&pg_lsn_ne>, true, true, TArgs_pg_lsn_ne_Policy>({}); }
+struct TArgs_pg_lsn_out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_jsonb_subscript_handler() { return &GenericExec<TPgDirectFunc<&jsonb_subscript_handler>, true, true, TArgs_jsonb_subscript_handler_Policy>; }
-struct TArgs_jsonb_typeof_Policy {
+TExecFunc arrow_pg_lsn_out() { return TGenericExec<TPgDirectFunc<&pg_lsn_out>, true, false, TArgs_pg_lsn_out_Policy>({}); }
+struct TArgs_pg_lsn_pli_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_jsonb_typeof() { return &GenericExec<TPgDirectFunc<&jsonb_typeof>, true, false, TArgs_jsonb_typeof_Policy>; }
-struct TArgs_length_in_encoding_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_length_in_encoding() { return &GenericExec<TPgDirectFunc<&length_in_encoding>, true, true, TArgs_length_in_encoding_Policy>; }
-struct TArgs_like_escape_Policy {
+TExecFunc arrow_pg_lsn_pli() { return TGenericExec<TPgDirectFunc<&pg_lsn_pli>, true, true, TArgs_pg_lsn_pli_Policy>({}); }
+struct TArgs_pg_lsn_recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_like_escape() { return &GenericExec<TPgDirectFunc<&like_escape>, true, false, TArgs_like_escape_Policy>; }
-struct TArgs_like_escape_bytea_Policy {
+TExecFunc arrow_pg_lsn_recv() { return TGenericExec<TPgDirectFunc<&pg_lsn_recv>, true, true, TArgs_pg_lsn_recv_Policy>({}); }
+struct TArgs_pg_lsn_send_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_like_escape_bytea() { return &GenericExec<TPgDirectFunc<&like_escape_bytea>, true, false, TArgs_like_escape_bytea_Policy>; }
-struct TArgs_line_construct_pp_Policy {
+TExecFunc arrow_pg_lsn_send() { return TGenericExec<TPgDirectFunc<&pg_lsn_send>, true, false, TArgs_pg_lsn_send_Policy>({}); }
+struct TArgs_pg_lsn_smaller_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_line_construct_pp() { return &GenericExec<TPgDirectFunc<&line_construct_pp>, true, false, TArgs_line_construct_pp_Policy>; }
-struct TArgs_line_distance_Policy {
+TExecFunc arrow_pg_lsn_smaller() { return TGenericExec<TPgDirectFunc<&pg_lsn_smaller>, true, true, TArgs_pg_lsn_smaller_Policy>({}); }
+struct TArgs_pg_my_temp_schema_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_line_distance() { return &GenericExec<TPgDirectFunc<&line_distance>, true, true, TArgs_line_distance_Policy>; }
-struct TArgs_line_eq_Policy {
+TExecFunc arrow_pg_my_temp_schema() { return TGenericExec<TPgDirectFunc<&pg_my_temp_schema>, true, true, TArgs_pg_my_temp_schema_Policy>({}); }
+struct TArgs_pg_node_tree_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_line_eq() { return &GenericExec<TPgDirectFunc<&line_eq>, true, true, TArgs_line_eq_Policy>; }
-struct TArgs_line_horizontal_Policy {
+TExecFunc arrow_pg_node_tree_in() { return TGenericExec<TPgDirectFunc<&pg_node_tree_in>, true, false, TArgs_pg_node_tree_in_Policy>({}); }
+struct TArgs_pg_node_tree_out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_line_horizontal() { return &GenericExec<TPgDirectFunc<&line_horizontal>, true, true, TArgs_line_horizontal_Policy>; }
-struct TArgs_line_in_Policy {
+TExecFunc arrow_pg_node_tree_out() { return TGenericExec<TPgDirectFunc<&pg_node_tree_out>, true, false, TArgs_pg_node_tree_out_Policy>({}); }
+struct TArgs_pg_node_tree_recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_line_in() { return &GenericExec<TPgDirectFunc<&line_in>, true, false, TArgs_line_in_Policy>; }
-struct TArgs_line_interpt_Policy {
+TExecFunc arrow_pg_node_tree_recv() { return TGenericExec<TPgDirectFunc<&pg_node_tree_recv>, true, false, TArgs_pg_node_tree_recv_Policy>({}); }
+struct TArgs_pg_node_tree_send_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_line_interpt() { return &GenericExec<TPgDirectFunc<&line_interpt>, true, false, TArgs_line_interpt_Policy>; }
-struct TArgs_line_intersect_Policy {
+TExecFunc arrow_pg_node_tree_send() { return TGenericExec<TPgDirectFunc<&pg_node_tree_send>, true, false, TArgs_pg_node_tree_send_Policy>({}); }
+struct TArgs_pg_opclass_is_visible_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_line_intersect() { return &GenericExec<TPgDirectFunc<&line_intersect>, true, true, TArgs_line_intersect_Policy>; }
-struct TArgs_line_out_Policy {
+TExecFunc arrow_pg_opclass_is_visible() { return TGenericExec<TPgDirectFunc<&pg_opclass_is_visible>, true, true, TArgs_pg_opclass_is_visible_Policy>({}); }
+struct TArgs_pg_operator_is_visible_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_line_out() { return &GenericExec<TPgDirectFunc<&line_out>, true, false, TArgs_line_out_Policy>; }
-struct TArgs_line_parallel_Policy {
+TExecFunc arrow_pg_operator_is_visible() { return TGenericExec<TPgDirectFunc<&pg_operator_is_visible>, true, true, TArgs_pg_operator_is_visible_Policy>({}); }
+struct TArgs_pg_opfamily_is_visible_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_line_parallel() { return &GenericExec<TPgDirectFunc<&line_parallel>, true, true, TArgs_line_parallel_Policy>; }
-struct TArgs_line_perp_Policy {
+TExecFunc arrow_pg_opfamily_is_visible() { return TGenericExec<TPgDirectFunc<&pg_opfamily_is_visible>, true, true, TArgs_pg_opfamily_is_visible_Policy>({}); }
+struct TArgs_pg_promote_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_line_perp() { return &GenericExec<TPgDirectFunc<&line_perp>, true, true, TArgs_line_perp_Policy>; }
-struct TArgs_line_recv_Policy {
+TExecFunc arrow_pg_promote() { return TGenericExec<TPgDirectFunc<&pg_promote>, true, true, TArgs_pg_promote_Policy>({}); }
+struct TArgs_pg_relation_filenode_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_line_recv() { return &GenericExec<TPgDirectFunc<&line_recv>, true, false, TArgs_line_recv_Policy>; }
-struct TArgs_line_send_Policy {
+TExecFunc arrow_pg_relation_filenode() { return TGenericExec<TPgDirectFunc<&pg_relation_filenode>, true, true, TArgs_pg_relation_filenode_Policy>({}); }
+struct TArgs_pg_relation_filepath_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_line_send() { return &GenericExec<TPgDirectFunc<&line_send>, true, false, TArgs_line_send_Policy>; }
-struct TArgs_line_vertical_Policy {
+TExecFunc arrow_pg_relation_filepath() { return TGenericExec<TPgDirectFunc<&pg_relation_filepath>, true, false, TArgs_pg_relation_filepath_Policy>({}); }
+struct TArgs_pg_relation_size_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_line_vertical() { return &GenericExec<TPgDirectFunc<&line_vertical>, true, true, TArgs_line_vertical_Policy>; }
-struct TArgs_lower_Policy {
+TExecFunc arrow_pg_relation_size() { return TGenericExec<TPgDirectFunc<&pg_relation_size>, true, true, TArgs_pg_relation_size_Policy>({}); }
+struct TArgs_pg_sequence_last_value_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_lower() { return &GenericExec<TPgDirectFunc<&lower>, true, false, TArgs_lower_Policy>; }
-struct TArgs_lpad_Policy {
+TExecFunc arrow_pg_sequence_last_value() { return TGenericExec<TPgDirectFunc<&pg_sequence_last_value>, true, true, TArgs_pg_sequence_last_value_Policy>({}); }
+struct TArgs_pg_sequence_parameters_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_lpad() { return &GenericExec<TPgDirectFunc<&lpad>, true, false, TArgs_lpad_Policy>; }
-struct TArgs_lseg_center_Policy {
+TExecFunc arrow_pg_sequence_parameters() { return TGenericExec<TPgDirectFunc<&pg_sequence_parameters>, true, false, TArgs_pg_sequence_parameters_Policy>({}); }
+struct TArgs_pg_size_bytes_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_lseg_center() { return &GenericExec<TPgDirectFunc<&lseg_center>, true, false, TArgs_lseg_center_Policy>; }
-struct TArgs_lseg_construct_Policy {
+TExecFunc arrow_pg_size_bytes() { return TGenericExec<TPgDirectFunc<&pg_size_bytes>, true, true, TArgs_pg_size_bytes_Policy>({}); }
+struct TArgs_pg_size_pretty_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_lseg_construct() { return &GenericExec<TPgDirectFunc<&lseg_construct>, true, false, TArgs_lseg_construct_Policy>; }
-struct TArgs_lseg_distance_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_lseg_distance() { return &GenericExec<TPgDirectFunc<&lseg_distance>, true, true, TArgs_lseg_distance_Policy>; }
-struct TArgs_lseg_eq_Policy {
+TExecFunc arrow_pg_size_pretty() { return TGenericExec<TPgDirectFunc<&pg_size_pretty>, true, false, TArgs_pg_size_pretty_Policy>({}); }
+struct TArgs_pg_size_pretty_numeric_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_lseg_eq() { return &GenericExec<TPgDirectFunc<&lseg_eq>, true, true, TArgs_lseg_eq_Policy>; }
-struct TArgs_lseg_ge_Policy {
+TExecFunc arrow_pg_size_pretty_numeric() { return TGenericExec<TPgDirectFunc<&pg_size_pretty_numeric>, true, false, TArgs_pg_size_pretty_numeric_Policy>({}); }
+struct TArgs_pg_start_backup_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_lseg_ge() { return &GenericExec<TPgDirectFunc<&lseg_ge>, true, true, TArgs_lseg_ge_Policy>; }
-struct TArgs_lseg_gt_Policy {
+TExecFunc arrow_pg_start_backup() { return TGenericExec<TPgDirectFunc<&pg_start_backup>, true, true, TArgs_pg_start_backup_Policy>({}); }
+struct TArgs_pg_stat_clear_snapshot_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_lseg_gt() { return &GenericExec<TPgDirectFunc<&lseg_gt>, true, true, TArgs_lseg_gt_Policy>; }
-struct TArgs_lseg_horizontal_Policy {
+TExecFunc arrow_pg_stat_clear_snapshot() { return TGenericExec<TPgDirectFunc<&pg_stat_clear_snapshot>, false, true, TArgs_pg_stat_clear_snapshot_Policy>({}); }
+struct TArgs_pg_stat_get_analyze_count_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_lseg_horizontal() { return &GenericExec<TPgDirectFunc<&lseg_horizontal>, true, true, TArgs_lseg_horizontal_Policy>; }
-struct TArgs_lseg_in_Policy {
+TExecFunc arrow_pg_stat_get_analyze_count() { return TGenericExec<TPgDirectFunc<&pg_stat_get_analyze_count>, true, true, TArgs_pg_stat_get_analyze_count_Policy>({}); }
+struct TArgs_pg_stat_get_archiver_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_lseg_in() { return &GenericExec<TPgDirectFunc<&lseg_in>, true, false, TArgs_lseg_in_Policy>; }
-struct TArgs_lseg_interpt_Policy {
+TExecFunc arrow_pg_stat_get_archiver() { return TGenericExec<TPgDirectFunc<&pg_stat_get_archiver>, false, false, TArgs_pg_stat_get_archiver_Policy>({}); }
+struct TArgs_pg_stat_get_autoanalyze_count_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_lseg_interpt() { return &GenericExec<TPgDirectFunc<&lseg_interpt>, true, false, TArgs_lseg_interpt_Policy>; }
-struct TArgs_lseg_intersect_Policy {
+TExecFunc arrow_pg_stat_get_autoanalyze_count() { return TGenericExec<TPgDirectFunc<&pg_stat_get_autoanalyze_count>, true, true, TArgs_pg_stat_get_autoanalyze_count_Policy>({}); }
+struct TArgs_pg_stat_get_autovacuum_count_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_lseg_intersect() { return &GenericExec<TPgDirectFunc<&lseg_intersect>, true, true, TArgs_lseg_intersect_Policy>; }
-struct TArgs_lseg_le_Policy {
+TExecFunc arrow_pg_stat_get_autovacuum_count() { return TGenericExec<TPgDirectFunc<&pg_stat_get_autovacuum_count>, true, true, TArgs_pg_stat_get_autovacuum_count_Policy>({}); }
+struct TArgs_pg_stat_get_backend_activity_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_lseg_le() { return &GenericExec<TPgDirectFunc<&lseg_le>, true, true, TArgs_lseg_le_Policy>; }
-struct TArgs_lseg_length_Policy {
+TExecFunc arrow_pg_stat_get_backend_activity() { return TGenericExec<TPgDirectFunc<&pg_stat_get_backend_activity>, true, false, TArgs_pg_stat_get_backend_activity_Policy>({}); }
+struct TArgs_pg_stat_get_backend_activity_start_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_lseg_length() { return &GenericExec<TPgDirectFunc<&lseg_length>, true, true, TArgs_lseg_length_Policy>; }
-struct TArgs_lseg_lt_Policy {
+TExecFunc arrow_pg_stat_get_backend_activity_start() { return TGenericExec<TPgDirectFunc<&pg_stat_get_backend_activity_start>, true, true, TArgs_pg_stat_get_backend_activity_start_Policy>({}); }
+struct TArgs_pg_stat_get_backend_client_addr_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_lseg_lt() { return &GenericExec<TPgDirectFunc<&lseg_lt>, true, true, TArgs_lseg_lt_Policy>; }
-struct TArgs_lseg_ne_Policy {
+TExecFunc arrow_pg_stat_get_backend_client_addr() { return TGenericExec<TPgDirectFunc<&pg_stat_get_backend_client_addr>, true, false, TArgs_pg_stat_get_backend_client_addr_Policy>({}); }
+struct TArgs_pg_stat_get_backend_client_port_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_lseg_ne() { return &GenericExec<TPgDirectFunc<&lseg_ne>, true, true, TArgs_lseg_ne_Policy>; }
-struct TArgs_lseg_out_Policy {
+TExecFunc arrow_pg_stat_get_backend_client_port() { return TGenericExec<TPgDirectFunc<&pg_stat_get_backend_client_port>, true, true, TArgs_pg_stat_get_backend_client_port_Policy>({}); }
+struct TArgs_pg_stat_get_backend_dbid_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_lseg_out() { return &GenericExec<TPgDirectFunc<&lseg_out>, true, false, TArgs_lseg_out_Policy>; }
-struct TArgs_lseg_parallel_Policy {
+TExecFunc arrow_pg_stat_get_backend_dbid() { return TGenericExec<TPgDirectFunc<&pg_stat_get_backend_dbid>, true, true, TArgs_pg_stat_get_backend_dbid_Policy>({}); }
+struct TArgs_pg_stat_get_backend_pid_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_lseg_parallel() { return &GenericExec<TPgDirectFunc<&lseg_parallel>, true, true, TArgs_lseg_parallel_Policy>; }
-struct TArgs_lseg_perp_Policy {
+TExecFunc arrow_pg_stat_get_backend_pid() { return TGenericExec<TPgDirectFunc<&pg_stat_get_backend_pid>, true, true, TArgs_pg_stat_get_backend_pid_Policy>({}); }
+struct TArgs_pg_stat_get_backend_start_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_lseg_perp() { return &GenericExec<TPgDirectFunc<&lseg_perp>, true, true, TArgs_lseg_perp_Policy>; }
-struct TArgs_lseg_recv_Policy {
+TExecFunc arrow_pg_stat_get_backend_start() { return TGenericExec<TPgDirectFunc<&pg_stat_get_backend_start>, true, true, TArgs_pg_stat_get_backend_start_Policy>({}); }
+struct TArgs_pg_stat_get_backend_userid_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_lseg_recv() { return &GenericExec<TPgDirectFunc<&lseg_recv>, true, false, TArgs_lseg_recv_Policy>; }
-struct TArgs_lseg_send_Policy {
+TExecFunc arrow_pg_stat_get_backend_userid() { return TGenericExec<TPgDirectFunc<&pg_stat_get_backend_userid>, true, true, TArgs_pg_stat_get_backend_userid_Policy>({}); }
+struct TArgs_pg_stat_get_backend_wait_event_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_lseg_send() { return &GenericExec<TPgDirectFunc<&lseg_send>, true, false, TArgs_lseg_send_Policy>; }
-struct TArgs_lseg_vertical_Policy {
+TExecFunc arrow_pg_stat_get_backend_wait_event() { return TGenericExec<TPgDirectFunc<&pg_stat_get_backend_wait_event>, true, false, TArgs_pg_stat_get_backend_wait_event_Policy>({}); }
+struct TArgs_pg_stat_get_backend_wait_event_type_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_lseg_vertical() { return &GenericExec<TPgDirectFunc<&lseg_vertical>, true, true, TArgs_lseg_vertical_Policy>; }
-struct TArgs_ltrim_Policy {
+TExecFunc arrow_pg_stat_get_backend_wait_event_type() { return TGenericExec<TPgDirectFunc<&pg_stat_get_backend_wait_event_type>, true, false, TArgs_pg_stat_get_backend_wait_event_type_Policy>({}); }
+struct TArgs_pg_stat_get_backend_xact_start_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_ltrim() { return &GenericExec<TPgDirectFunc<&ltrim>, true, false, TArgs_ltrim_Policy>; }
-struct TArgs_ltrim1_Policy {
+TExecFunc arrow_pg_stat_get_backend_xact_start() { return TGenericExec<TPgDirectFunc<&pg_stat_get_backend_xact_start>, true, true, TArgs_pg_stat_get_backend_xact_start_Policy>({}); }
+struct TArgs_pg_stat_get_bgwriter_buf_written_checkpoints_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_ltrim1() { return &GenericExec<TPgDirectFunc<&ltrim1>, true, false, TArgs_ltrim1_Policy>; }
-struct TArgs_makeaclitem_Policy {
+TExecFunc arrow_pg_stat_get_bgwriter_buf_written_checkpoints() { return TGenericExec<TPgDirectFunc<&pg_stat_get_bgwriter_buf_written_checkpoints>, true, true, TArgs_pg_stat_get_bgwriter_buf_written_checkpoints_Policy>({}); }
+struct TArgs_pg_stat_get_bgwriter_buf_written_clean_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,false,true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_makeaclitem() { return &GenericExec<TPgDirectFunc<&makeaclitem>, true, false, TArgs_makeaclitem_Policy>; }
-struct TArgs_matchingjoinsel_Policy {
+TExecFunc arrow_pg_stat_get_bgwriter_buf_written_clean() { return TGenericExec<TPgDirectFunc<&pg_stat_get_bgwriter_buf_written_clean>, true, true, TArgs_pg_stat_get_bgwriter_buf_written_clean_Policy>({}); }
+struct TArgs_pg_stat_get_bgwriter_maxwritten_clean_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_matchingjoinsel() { return &GenericExec<TPgDirectFunc<&matchingjoinsel>, true, true, TArgs_matchingjoinsel_Policy>; }
-struct TArgs_matchingsel_Policy {
+TExecFunc arrow_pg_stat_get_bgwriter_maxwritten_clean() { return TGenericExec<TPgDirectFunc<&pg_stat_get_bgwriter_maxwritten_clean>, true, true, TArgs_pg_stat_get_bgwriter_maxwritten_clean_Policy>({}); }
+struct TArgs_pg_stat_get_bgwriter_requested_checkpoints_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_matchingsel() { return &GenericExec<TPgDirectFunc<&matchingsel>, true, true, TArgs_matchingsel_Policy>; }
-struct TArgs_md5_bytea_Policy {
+TExecFunc arrow_pg_stat_get_bgwriter_requested_checkpoints() { return TGenericExec<TPgDirectFunc<&pg_stat_get_bgwriter_requested_checkpoints>, true, true, TArgs_pg_stat_get_bgwriter_requested_checkpoints_Policy>({}); }
+struct TArgs_pg_stat_get_bgwriter_stat_reset_time_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_md5_bytea() { return &GenericExec<TPgDirectFunc<&md5_bytea>, true, false, TArgs_md5_bytea_Policy>; }
-struct TArgs_md5_text_Policy {
+TExecFunc arrow_pg_stat_get_bgwriter_stat_reset_time() { return TGenericExec<TPgDirectFunc<&pg_stat_get_bgwriter_stat_reset_time>, true, true, TArgs_pg_stat_get_bgwriter_stat_reset_time_Policy>({}); }
+struct TArgs_pg_stat_get_bgwriter_timed_checkpoints_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_md5_text() { return &GenericExec<TPgDirectFunc<&md5_text>, true, false, TArgs_md5_text_Policy>; }
-struct TArgs_multirange_typanalyze_Policy {
+TExecFunc arrow_pg_stat_get_bgwriter_timed_checkpoints() { return TGenericExec<TPgDirectFunc<&pg_stat_get_bgwriter_timed_checkpoints>, true, true, TArgs_pg_stat_get_bgwriter_timed_checkpoints_Policy>({}); }
+struct TArgs_pg_stat_get_blocks_fetched_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_multirange_typanalyze() { return &GenericExec<TPgDirectFunc<&multirange_typanalyze>, true, true, TArgs_multirange_typanalyze_Policy>; }
-struct TArgs_name_bpchar_Policy {
+TExecFunc arrow_pg_stat_get_blocks_fetched() { return TGenericExec<TPgDirectFunc<&pg_stat_get_blocks_fetched>, true, true, TArgs_pg_stat_get_blocks_fetched_Policy>({}); }
+struct TArgs_pg_stat_get_blocks_hit_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_name_bpchar() { return &GenericExec<TPgDirectFunc<&name_bpchar>, true, false, TArgs_name_bpchar_Policy>; }
-struct TArgs_nameiclike_Policy {
+TExecFunc arrow_pg_stat_get_blocks_hit() { return TGenericExec<TPgDirectFunc<&pg_stat_get_blocks_hit>, true, true, TArgs_pg_stat_get_blocks_hit_Policy>({}); }
+struct TArgs_pg_stat_get_buf_alloc_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_nameiclike() { return &GenericExec<TPgDirectFunc<&nameiclike>, true, true, TArgs_nameiclike_Policy>; }
-struct TArgs_nameicnlike_Policy {
+TExecFunc arrow_pg_stat_get_buf_alloc() { return TGenericExec<TPgDirectFunc<&pg_stat_get_buf_alloc>, true, true, TArgs_pg_stat_get_buf_alloc_Policy>({}); }
+struct TArgs_pg_stat_get_buf_fsync_backend_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_nameicnlike() { return &GenericExec<TPgDirectFunc<&nameicnlike>, true, true, TArgs_nameicnlike_Policy>; }
-struct TArgs_namelike_Policy {
+TExecFunc arrow_pg_stat_get_buf_fsync_backend() { return TGenericExec<TPgDirectFunc<&pg_stat_get_buf_fsync_backend>, true, true, TArgs_pg_stat_get_buf_fsync_backend_Policy>({}); }
+struct TArgs_pg_stat_get_buf_written_backend_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_namelike() { return &GenericExec<TPgDirectFunc<&namelike>, true, true, TArgs_namelike_Policy>; }
-struct TArgs_namenlike_Policy {
+TExecFunc arrow_pg_stat_get_buf_written_backend() { return TGenericExec<TPgDirectFunc<&pg_stat_get_buf_written_backend>, true, true, TArgs_pg_stat_get_buf_written_backend_Policy>({}); }
+struct TArgs_pg_stat_get_checkpoint_sync_time_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_namenlike() { return &GenericExec<TPgDirectFunc<&namenlike>, true, true, TArgs_namenlike_Policy>; }
-struct TArgs_neqjoinsel_Policy {
+TExecFunc arrow_pg_stat_get_checkpoint_sync_time() { return TGenericExec<TPgDirectFunc<&pg_stat_get_checkpoint_sync_time>, true, true, TArgs_pg_stat_get_checkpoint_sync_time_Policy>({}); }
+struct TArgs_pg_stat_get_checkpoint_write_time_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_neqjoinsel() { return &GenericExec<TPgDirectFunc<&neqjoinsel>, true, true, TArgs_neqjoinsel_Policy>; }
-struct TArgs_neqsel_Policy {
+TExecFunc arrow_pg_stat_get_checkpoint_write_time() { return TGenericExec<TPgDirectFunc<&pg_stat_get_checkpoint_write_time>, true, true, TArgs_pg_stat_get_checkpoint_write_time_Policy>({}); }
+struct TArgs_pg_stat_get_db_active_time_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_neqsel() { return &GenericExec<TPgDirectFunc<&neqsel>, true, true, TArgs_neqsel_Policy>; }
-struct TArgs_network_broadcast_Policy {
+TExecFunc arrow_pg_stat_get_db_active_time() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_active_time>, true, true, TArgs_pg_stat_get_db_active_time_Policy>({}); }
+struct TArgs_pg_stat_get_db_blk_read_time_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_network_broadcast() { return &GenericExec<TPgDirectFunc<&network_broadcast>, true, false, TArgs_network_broadcast_Policy>; }
-struct TArgs_network_cmp_Policy {
+TExecFunc arrow_pg_stat_get_db_blk_read_time() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_blk_read_time>, true, true, TArgs_pg_stat_get_db_blk_read_time_Policy>({}); }
+struct TArgs_pg_stat_get_db_blk_write_time_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_network_cmp() { return &GenericExec<TPgDirectFunc<&network_cmp>, true, true, TArgs_network_cmp_Policy>; }
-struct TArgs_network_eq_Policy {
+TExecFunc arrow_pg_stat_get_db_blk_write_time() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_blk_write_time>, true, true, TArgs_pg_stat_get_db_blk_write_time_Policy>({}); }
+struct TArgs_pg_stat_get_db_blocks_fetched_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_network_eq() { return &GenericExec<TPgDirectFunc<&network_eq>, true, true, TArgs_network_eq_Policy>; }
-struct TArgs_network_family_Policy {
+TExecFunc arrow_pg_stat_get_db_blocks_fetched() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_blocks_fetched>, true, true, TArgs_pg_stat_get_db_blocks_fetched_Policy>({}); }
+struct TArgs_pg_stat_get_db_blocks_hit_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_network_family() { return &GenericExec<TPgDirectFunc<&network_family>, true, true, TArgs_network_family_Policy>; }
-struct TArgs_network_ge_Policy {
+TExecFunc arrow_pg_stat_get_db_blocks_hit() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_blocks_hit>, true, true, TArgs_pg_stat_get_db_blocks_hit_Policy>({}); }
+struct TArgs_pg_stat_get_db_checksum_failures_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_network_ge() { return &GenericExec<TPgDirectFunc<&network_ge>, true, true, TArgs_network_ge_Policy>; }
-struct TArgs_network_gt_Policy {
+TExecFunc arrow_pg_stat_get_db_checksum_failures() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_checksum_failures>, true, true, TArgs_pg_stat_get_db_checksum_failures_Policy>({}); }
+struct TArgs_pg_stat_get_db_checksum_last_failure_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_network_gt() { return &GenericExec<TPgDirectFunc<&network_gt>, true, true, TArgs_network_gt_Policy>; }
-struct TArgs_network_host_Policy {
+TExecFunc arrow_pg_stat_get_db_checksum_last_failure() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_checksum_last_failure>, true, true, TArgs_pg_stat_get_db_checksum_last_failure_Policy>({}); }
+struct TArgs_pg_stat_get_db_conflict_all_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_network_host() { return &GenericExec<TPgDirectFunc<&network_host>, true, false, TArgs_network_host_Policy>; }
-struct TArgs_network_hostmask_Policy {
+TExecFunc arrow_pg_stat_get_db_conflict_all() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_conflict_all>, true, true, TArgs_pg_stat_get_db_conflict_all_Policy>({}); }
+struct TArgs_pg_stat_get_db_conflict_bufferpin_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_network_hostmask() { return &GenericExec<TPgDirectFunc<&network_hostmask>, true, false, TArgs_network_hostmask_Policy>; }
-struct TArgs_network_larger_Policy {
+TExecFunc arrow_pg_stat_get_db_conflict_bufferpin() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_conflict_bufferpin>, true, true, TArgs_pg_stat_get_db_conflict_bufferpin_Policy>({}); }
+struct TArgs_pg_stat_get_db_conflict_lock_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_network_larger() { return &GenericExec<TPgDirectFunc<&network_larger>, true, false, TArgs_network_larger_Policy>; }
-struct TArgs_network_le_Policy {
+TExecFunc arrow_pg_stat_get_db_conflict_lock() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_conflict_lock>, true, true, TArgs_pg_stat_get_db_conflict_lock_Policy>({}); }
+struct TArgs_pg_stat_get_db_conflict_snapshot_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_network_le() { return &GenericExec<TPgDirectFunc<&network_le>, true, true, TArgs_network_le_Policy>; }
-struct TArgs_network_lt_Policy {
+TExecFunc arrow_pg_stat_get_db_conflict_snapshot() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_conflict_snapshot>, true, true, TArgs_pg_stat_get_db_conflict_snapshot_Policy>({}); }
+struct TArgs_pg_stat_get_db_conflict_startup_deadlock_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_network_lt() { return &GenericExec<TPgDirectFunc<&network_lt>, true, true, TArgs_network_lt_Policy>; }
-struct TArgs_network_masklen_Policy {
+TExecFunc arrow_pg_stat_get_db_conflict_startup_deadlock() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_conflict_startup_deadlock>, true, true, TArgs_pg_stat_get_db_conflict_startup_deadlock_Policy>({}); }
+struct TArgs_pg_stat_get_db_conflict_tablespace_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_network_masklen() { return &GenericExec<TPgDirectFunc<&network_masklen>, true, true, TArgs_network_masklen_Policy>; }
-struct TArgs_network_ne_Policy {
+TExecFunc arrow_pg_stat_get_db_conflict_tablespace() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_conflict_tablespace>, true, true, TArgs_pg_stat_get_db_conflict_tablespace_Policy>({}); }
+struct TArgs_pg_stat_get_db_deadlocks_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_network_ne() { return &GenericExec<TPgDirectFunc<&network_ne>, true, true, TArgs_network_ne_Policy>; }
-struct TArgs_network_netmask_Policy {
+TExecFunc arrow_pg_stat_get_db_deadlocks() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_deadlocks>, true, true, TArgs_pg_stat_get_db_deadlocks_Policy>({}); }
+struct TArgs_pg_stat_get_db_idle_in_transaction_time_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_network_netmask() { return &GenericExec<TPgDirectFunc<&network_netmask>, true, false, TArgs_network_netmask_Policy>; }
-struct TArgs_network_network_Policy {
+TExecFunc arrow_pg_stat_get_db_idle_in_transaction_time() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_idle_in_transaction_time>, true, true, TArgs_pg_stat_get_db_idle_in_transaction_time_Policy>({}); }
+struct TArgs_pg_stat_get_db_numbackends_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_network_network() { return &GenericExec<TPgDirectFunc<&network_network>, true, false, TArgs_network_network_Policy>; }
-struct TArgs_network_overlap_Policy {
+TExecFunc arrow_pg_stat_get_db_numbackends() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_numbackends>, true, true, TArgs_pg_stat_get_db_numbackends_Policy>({}); }
+struct TArgs_pg_stat_get_db_session_time_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_network_overlap() { return &GenericExec<TPgDirectFunc<&network_overlap>, true, true, TArgs_network_overlap_Policy>; }
-struct TArgs_network_show_Policy {
+TExecFunc arrow_pg_stat_get_db_session_time() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_session_time>, true, true, TArgs_pg_stat_get_db_session_time_Policy>({}); }
+struct TArgs_pg_stat_get_db_sessions_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_network_show() { return &GenericExec<TPgDirectFunc<&network_show>, true, false, TArgs_network_show_Policy>; }
-struct TArgs_network_smaller_Policy {
+TExecFunc arrow_pg_stat_get_db_sessions() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_sessions>, true, true, TArgs_pg_stat_get_db_sessions_Policy>({}); }
+struct TArgs_pg_stat_get_db_sessions_abandoned_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_network_smaller() { return &GenericExec<TPgDirectFunc<&network_smaller>, true, false, TArgs_network_smaller_Policy>; }
-struct TArgs_network_sortsupport_Policy {
+TExecFunc arrow_pg_stat_get_db_sessions_abandoned() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_sessions_abandoned>, true, true, TArgs_pg_stat_get_db_sessions_abandoned_Policy>({}); }
+struct TArgs_pg_stat_get_db_sessions_fatal_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_network_sortsupport() { return &GenericExec<TPgDirectFunc<&network_sortsupport>, true, true, TArgs_network_sortsupport_Policy>; }
-struct TArgs_network_sub_Policy {
+TExecFunc arrow_pg_stat_get_db_sessions_fatal() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_sessions_fatal>, true, true, TArgs_pg_stat_get_db_sessions_fatal_Policy>({}); }
+struct TArgs_pg_stat_get_db_sessions_killed_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_network_sub() { return &GenericExec<TPgDirectFunc<&network_sub>, true, true, TArgs_network_sub_Policy>; }
-struct TArgs_network_subeq_Policy {
+TExecFunc arrow_pg_stat_get_db_sessions_killed() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_sessions_killed>, true, true, TArgs_pg_stat_get_db_sessions_killed_Policy>({}); }
+struct TArgs_pg_stat_get_db_stat_reset_time_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_network_subeq() { return &GenericExec<TPgDirectFunc<&network_subeq>, true, true, TArgs_network_subeq_Policy>; }
-struct TArgs_network_subset_support_Policy {
+TExecFunc arrow_pg_stat_get_db_stat_reset_time() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_stat_reset_time>, true, true, TArgs_pg_stat_get_db_stat_reset_time_Policy>({}); }
+struct TArgs_pg_stat_get_db_temp_bytes_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_network_subset_support() { return &GenericExec<TPgDirectFunc<&network_subset_support>, true, true, TArgs_network_subset_support_Policy>; }
-struct TArgs_network_sup_Policy {
+TExecFunc arrow_pg_stat_get_db_temp_bytes() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_temp_bytes>, true, true, TArgs_pg_stat_get_db_temp_bytes_Policy>({}); }
+struct TArgs_pg_stat_get_db_temp_files_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_network_sup() { return &GenericExec<TPgDirectFunc<&network_sup>, true, true, TArgs_network_sup_Policy>; }
-struct TArgs_network_supeq_Policy {
+TExecFunc arrow_pg_stat_get_db_temp_files() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_temp_files>, true, true, TArgs_pg_stat_get_db_temp_files_Policy>({}); }
+struct TArgs_pg_stat_get_db_tuples_deleted_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_network_supeq() { return &GenericExec<TPgDirectFunc<&network_supeq>, true, true, TArgs_network_supeq_Policy>; }
-struct TArgs_numeric_to_char_Policy {
+TExecFunc arrow_pg_stat_get_db_tuples_deleted() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_tuples_deleted>, true, true, TArgs_pg_stat_get_db_tuples_deleted_Policy>({}); }
+struct TArgs_pg_stat_get_db_tuples_fetched_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_numeric_to_char() { return &GenericExec<TPgDirectFunc<&numeric_to_char>, true, false, TArgs_numeric_to_char_Policy>; }
-struct TArgs_numeric_to_number_Policy {
+TExecFunc arrow_pg_stat_get_db_tuples_fetched() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_tuples_fetched>, true, true, TArgs_pg_stat_get_db_tuples_fetched_Policy>({}); }
+struct TArgs_pg_stat_get_db_tuples_inserted_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_numeric_to_number() { return &GenericExec<TPgDirectFunc<&numeric_to_number>, true, false, TArgs_numeric_to_number_Policy>; }
-struct TArgs_on_pb_Policy {
+TExecFunc arrow_pg_stat_get_db_tuples_inserted() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_tuples_inserted>, true, true, TArgs_pg_stat_get_db_tuples_inserted_Policy>({}); }
+struct TArgs_pg_stat_get_db_tuples_returned_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_on_pb() { return &GenericExec<TPgDirectFunc<&on_pb>, true, true, TArgs_on_pb_Policy>; }
-struct TArgs_on_pl_Policy {
+TExecFunc arrow_pg_stat_get_db_tuples_returned() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_tuples_returned>, true, true, TArgs_pg_stat_get_db_tuples_returned_Policy>({}); }
+struct TArgs_pg_stat_get_db_tuples_updated_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_on_pl() { return &GenericExec<TPgDirectFunc<&on_pl>, true, true, TArgs_on_pl_Policy>; }
-struct TArgs_on_ppath_Policy {
+TExecFunc arrow_pg_stat_get_db_tuples_updated() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_tuples_updated>, true, true, TArgs_pg_stat_get_db_tuples_updated_Policy>({}); }
+struct TArgs_pg_stat_get_db_xact_commit_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_on_ppath() { return &GenericExec<TPgDirectFunc<&on_ppath>, true, true, TArgs_on_ppath_Policy>; }
-struct TArgs_on_ps_Policy {
+TExecFunc arrow_pg_stat_get_db_xact_commit() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_xact_commit>, true, true, TArgs_pg_stat_get_db_xact_commit_Policy>({}); }
+struct TArgs_pg_stat_get_db_xact_rollback_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_on_ps() { return &GenericExec<TPgDirectFunc<&on_ps>, true, true, TArgs_on_ps_Policy>; }
-struct TArgs_on_sb_Policy {
+TExecFunc arrow_pg_stat_get_db_xact_rollback() { return TGenericExec<TPgDirectFunc<&pg_stat_get_db_xact_rollback>, true, true, TArgs_pg_stat_get_db_xact_rollback_Policy>({}); }
+struct TArgs_pg_stat_get_dead_tuples_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_on_sb() { return &GenericExec<TPgDirectFunc<&on_sb>, true, true, TArgs_on_sb_Policy>; }
-struct TArgs_on_sl_Policy {
+TExecFunc arrow_pg_stat_get_dead_tuples() { return TGenericExec<TPgDirectFunc<&pg_stat_get_dead_tuples>, true, true, TArgs_pg_stat_get_dead_tuples_Policy>({}); }
+struct TArgs_pg_stat_get_function_calls_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_on_sl() { return &GenericExec<TPgDirectFunc<&on_sl>, true, true, TArgs_on_sl_Policy>; }
-struct TArgs_path_add_Policy {
+TExecFunc arrow_pg_stat_get_function_calls() { return TGenericExec<TPgDirectFunc<&pg_stat_get_function_calls>, true, true, TArgs_pg_stat_get_function_calls_Policy>({}); }
+struct TArgs_pg_stat_get_function_self_time_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_path_add() { return &GenericExec<TPgDirectFunc<&path_add>, true, false, TArgs_path_add_Policy>; }
-struct TArgs_path_add_pt_Policy {
+TExecFunc arrow_pg_stat_get_function_self_time() { return TGenericExec<TPgDirectFunc<&pg_stat_get_function_self_time>, true, true, TArgs_pg_stat_get_function_self_time_Policy>({}); }
+struct TArgs_pg_stat_get_function_total_time_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_path_add_pt() { return &GenericExec<TPgDirectFunc<&path_add_pt>, true, false, TArgs_path_add_pt_Policy>; }
-struct TArgs_path_area_Policy {
+TExecFunc arrow_pg_stat_get_function_total_time() { return TGenericExec<TPgDirectFunc<&pg_stat_get_function_total_time>, true, true, TArgs_pg_stat_get_function_total_time_Policy>({}); }
+struct TArgs_pg_stat_get_ins_since_vacuum_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_path_area() { return &GenericExec<TPgDirectFunc<&path_area>, true, true, TArgs_path_area_Policy>; }
-struct TArgs_path_center_Policy {
+TExecFunc arrow_pg_stat_get_ins_since_vacuum() { return TGenericExec<TPgDirectFunc<&pg_stat_get_ins_since_vacuum>, true, true, TArgs_pg_stat_get_ins_since_vacuum_Policy>({}); }
+struct TArgs_pg_stat_get_last_analyze_time_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_path_center() { return &GenericExec<TPgDirectFunc<&path_center>, true, false, TArgs_path_center_Policy>; }
-struct TArgs_path_close_Policy {
+TExecFunc arrow_pg_stat_get_last_analyze_time() { return TGenericExec<TPgDirectFunc<&pg_stat_get_last_analyze_time>, true, true, TArgs_pg_stat_get_last_analyze_time_Policy>({}); }
+struct TArgs_pg_stat_get_last_autoanalyze_time_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_path_close() { return &GenericExec<TPgDirectFunc<&path_close>, true, false, TArgs_path_close_Policy>; }
-struct TArgs_path_distance_Policy {
+TExecFunc arrow_pg_stat_get_last_autoanalyze_time() { return TGenericExec<TPgDirectFunc<&pg_stat_get_last_autoanalyze_time>, true, true, TArgs_pg_stat_get_last_autoanalyze_time_Policy>({}); }
+struct TArgs_pg_stat_get_last_autovacuum_time_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_path_distance() { return &GenericExec<TPgDirectFunc<&path_distance>, true, true, TArgs_path_distance_Policy>; }
-struct TArgs_path_div_pt_Policy {
+TExecFunc arrow_pg_stat_get_last_autovacuum_time() { return TGenericExec<TPgDirectFunc<&pg_stat_get_last_autovacuum_time>, true, true, TArgs_pg_stat_get_last_autovacuum_time_Policy>({}); }
+struct TArgs_pg_stat_get_last_vacuum_time_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_path_div_pt() { return &GenericExec<TPgDirectFunc<&path_div_pt>, true, false, TArgs_path_div_pt_Policy>; }
-struct TArgs_path_in_Policy {
+TExecFunc arrow_pg_stat_get_last_vacuum_time() { return TGenericExec<TPgDirectFunc<&pg_stat_get_last_vacuum_time>, true, true, TArgs_pg_stat_get_last_vacuum_time_Policy>({}); }
+struct TArgs_pg_stat_get_live_tuples_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_path_in() { return &GenericExec<TPgDirectFunc<&path_in>, true, false, TArgs_path_in_Policy>; }
-struct TArgs_path_inter_Policy {
+TExecFunc arrow_pg_stat_get_live_tuples() { return TGenericExec<TPgDirectFunc<&pg_stat_get_live_tuples>, true, true, TArgs_pg_stat_get_live_tuples_Policy>({}); }
+struct TArgs_pg_stat_get_mod_since_analyze_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_path_inter() { return &GenericExec<TPgDirectFunc<&path_inter>, true, true, TArgs_path_inter_Policy>; }
-struct TArgs_path_isclosed_Policy {
+TExecFunc arrow_pg_stat_get_mod_since_analyze() { return TGenericExec<TPgDirectFunc<&pg_stat_get_mod_since_analyze>, true, true, TArgs_pg_stat_get_mod_since_analyze_Policy>({}); }
+struct TArgs_pg_stat_get_numscans_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_path_isclosed() { return &GenericExec<TPgDirectFunc<&path_isclosed>, true, true, TArgs_path_isclosed_Policy>; }
-struct TArgs_path_isopen_Policy {
+TExecFunc arrow_pg_stat_get_numscans() { return TGenericExec<TPgDirectFunc<&pg_stat_get_numscans>, true, true, TArgs_pg_stat_get_numscans_Policy>({}); }
+struct TArgs_pg_stat_get_snapshot_timestamp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_path_isopen() { return &GenericExec<TPgDirectFunc<&path_isopen>, true, true, TArgs_path_isopen_Policy>; }
-struct TArgs_path_length_Policy {
+TExecFunc arrow_pg_stat_get_snapshot_timestamp() { return TGenericExec<TPgDirectFunc<&pg_stat_get_snapshot_timestamp>, true, true, TArgs_pg_stat_get_snapshot_timestamp_Policy>({}); }
+struct TArgs_pg_stat_get_tuples_deleted_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_path_length() { return &GenericExec<TPgDirectFunc<&path_length>, true, true, TArgs_path_length_Policy>; }
-struct TArgs_path_mul_pt_Policy {
+TExecFunc arrow_pg_stat_get_tuples_deleted() { return TGenericExec<TPgDirectFunc<&pg_stat_get_tuples_deleted>, true, true, TArgs_pg_stat_get_tuples_deleted_Policy>({}); }
+struct TArgs_pg_stat_get_tuples_fetched_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_path_mul_pt() { return &GenericExec<TPgDirectFunc<&path_mul_pt>, true, false, TArgs_path_mul_pt_Policy>; }
-struct TArgs_path_n_eq_Policy {
+TExecFunc arrow_pg_stat_get_tuples_fetched() { return TGenericExec<TPgDirectFunc<&pg_stat_get_tuples_fetched>, true, true, TArgs_pg_stat_get_tuples_fetched_Policy>({}); }
+struct TArgs_pg_stat_get_tuples_hot_updated_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_path_n_eq() { return &GenericExec<TPgDirectFunc<&path_n_eq>, true, true, TArgs_path_n_eq_Policy>; }
-struct TArgs_path_n_ge_Policy {
+TExecFunc arrow_pg_stat_get_tuples_hot_updated() { return TGenericExec<TPgDirectFunc<&pg_stat_get_tuples_hot_updated>, true, true, TArgs_pg_stat_get_tuples_hot_updated_Policy>({}); }
+struct TArgs_pg_stat_get_tuples_inserted_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_path_n_ge() { return &GenericExec<TPgDirectFunc<&path_n_ge>, true, true, TArgs_path_n_ge_Policy>; }
-struct TArgs_path_n_gt_Policy {
+TExecFunc arrow_pg_stat_get_tuples_inserted() { return TGenericExec<TPgDirectFunc<&pg_stat_get_tuples_inserted>, true, true, TArgs_pg_stat_get_tuples_inserted_Policy>({}); }
+struct TArgs_pg_stat_get_tuples_returned_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_path_n_gt() { return &GenericExec<TPgDirectFunc<&path_n_gt>, true, true, TArgs_path_n_gt_Policy>; }
-struct TArgs_path_n_le_Policy {
+TExecFunc arrow_pg_stat_get_tuples_returned() { return TGenericExec<TPgDirectFunc<&pg_stat_get_tuples_returned>, true, true, TArgs_pg_stat_get_tuples_returned_Policy>({}); }
+struct TArgs_pg_stat_get_tuples_updated_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_path_n_le() { return &GenericExec<TPgDirectFunc<&path_n_le>, true, true, TArgs_path_n_le_Policy>; }
-struct TArgs_path_n_lt_Policy {
+TExecFunc arrow_pg_stat_get_tuples_updated() { return TGenericExec<TPgDirectFunc<&pg_stat_get_tuples_updated>, true, true, TArgs_pg_stat_get_tuples_updated_Policy>({}); }
+struct TArgs_pg_stat_get_vacuum_count_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_path_n_lt() { return &GenericExec<TPgDirectFunc<&path_n_lt>, true, true, TArgs_path_n_lt_Policy>; }
-struct TArgs_path_npoints_Policy {
+TExecFunc arrow_pg_stat_get_vacuum_count() { return TGenericExec<TPgDirectFunc<&pg_stat_get_vacuum_count>, true, true, TArgs_pg_stat_get_vacuum_count_Policy>({}); }
+struct TArgs_pg_stat_get_wal_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_path_npoints() { return &GenericExec<TPgDirectFunc<&path_npoints>, true, true, TArgs_path_npoints_Policy>; }
-struct TArgs_path_open_Policy {
+TExecFunc arrow_pg_stat_get_wal() { return TGenericExec<TPgDirectFunc<&pg_stat_get_wal>, false, false, TArgs_pg_stat_get_wal_Policy>({}); }
+struct TArgs_pg_stat_get_xact_blocks_fetched_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_path_open() { return &GenericExec<TPgDirectFunc<&path_open>, true, false, TArgs_path_open_Policy>; }
-struct TArgs_path_out_Policy {
+TExecFunc arrow_pg_stat_get_xact_blocks_fetched() { return TGenericExec<TPgDirectFunc<&pg_stat_get_xact_blocks_fetched>, true, true, TArgs_pg_stat_get_xact_blocks_fetched_Policy>({}); }
+struct TArgs_pg_stat_get_xact_blocks_hit_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_path_out() { return &GenericExec<TPgDirectFunc<&path_out>, true, false, TArgs_path_out_Policy>; }
-struct TArgs_path_poly_Policy {
+TExecFunc arrow_pg_stat_get_xact_blocks_hit() { return TGenericExec<TPgDirectFunc<&pg_stat_get_xact_blocks_hit>, true, true, TArgs_pg_stat_get_xact_blocks_hit_Policy>({}); }
+struct TArgs_pg_stat_get_xact_function_calls_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_path_poly() { return &GenericExec<TPgDirectFunc<&path_poly>, true, false, TArgs_path_poly_Policy>; }
-struct TArgs_path_recv_Policy {
+TExecFunc arrow_pg_stat_get_xact_function_calls() { return TGenericExec<TPgDirectFunc<&pg_stat_get_xact_function_calls>, true, true, TArgs_pg_stat_get_xact_function_calls_Policy>({}); }
+struct TArgs_pg_stat_get_xact_function_self_time_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_path_recv() { return &GenericExec<TPgDirectFunc<&path_recv>, true, false, TArgs_path_recv_Policy>; }
-struct TArgs_path_send_Policy {
+TExecFunc arrow_pg_stat_get_xact_function_self_time() { return TGenericExec<TPgDirectFunc<&pg_stat_get_xact_function_self_time>, true, true, TArgs_pg_stat_get_xact_function_self_time_Policy>({}); }
+struct TArgs_pg_stat_get_xact_function_total_time_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_path_send() { return &GenericExec<TPgDirectFunc<&path_send>, true, false, TArgs_path_send_Policy>; }
-struct TArgs_path_sub_pt_Policy {
+TExecFunc arrow_pg_stat_get_xact_function_total_time() { return TGenericExec<TPgDirectFunc<&pg_stat_get_xact_function_total_time>, true, true, TArgs_pg_stat_get_xact_function_total_time_Policy>({}); }
+struct TArgs_pg_stat_get_xact_numscans_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_path_sub_pt() { return &GenericExec<TPgDirectFunc<&path_sub_pt>, true, false, TArgs_path_sub_pt_Policy>; }
-struct TArgs_pg_client_encoding_Policy {
+TExecFunc arrow_pg_stat_get_xact_numscans() { return TGenericExec<TPgDirectFunc<&pg_stat_get_xact_numscans>, true, true, TArgs_pg_stat_get_xact_numscans_Policy>({}); }
+struct TArgs_pg_stat_get_xact_tuples_deleted_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_client_encoding() { return &GenericExec<TPgDirectFunc<&pg_client_encoding>, true, false, TArgs_pg_client_encoding_Policy>; }
-struct TArgs_pg_convert_Policy {
+TExecFunc arrow_pg_stat_get_xact_tuples_deleted() { return TGenericExec<TPgDirectFunc<&pg_stat_get_xact_tuples_deleted>, true, true, TArgs_pg_stat_get_xact_tuples_deleted_Policy>({}); }
+struct TArgs_pg_stat_get_xact_tuples_fetched_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_convert() { return &GenericExec<TPgDirectFunc<&pg_convert>, true, false, TArgs_pg_convert_Policy>; }
-struct TArgs_pg_convert_from_Policy {
+TExecFunc arrow_pg_stat_get_xact_tuples_fetched() { return TGenericExec<TPgDirectFunc<&pg_stat_get_xact_tuples_fetched>, true, true, TArgs_pg_stat_get_xact_tuples_fetched_Policy>({}); }
+struct TArgs_pg_stat_get_xact_tuples_hot_updated_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_convert_from() { return &GenericExec<TPgDirectFunc<&pg_convert_from>, true, false, TArgs_pg_convert_from_Policy>; }
-struct TArgs_pg_convert_to_Policy {
+TExecFunc arrow_pg_stat_get_xact_tuples_hot_updated() { return TGenericExec<TPgDirectFunc<&pg_stat_get_xact_tuples_hot_updated>, true, true, TArgs_pg_stat_get_xact_tuples_hot_updated_Policy>({}); }
+struct TArgs_pg_stat_get_xact_tuples_inserted_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_convert_to() { return &GenericExec<TPgDirectFunc<&pg_convert_to>, true, false, TArgs_pg_convert_to_Policy>; }
-struct TArgs_pg_copy_logical_replication_slot_a_Policy {
+TExecFunc arrow_pg_stat_get_xact_tuples_inserted() { return TGenericExec<TPgDirectFunc<&pg_stat_get_xact_tuples_inserted>, true, true, TArgs_pg_stat_get_xact_tuples_inserted_Policy>({}); }
+struct TArgs_pg_stat_get_xact_tuples_returned_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,false,true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_copy_logical_replication_slot_a() { return &GenericExec<TPgDirectFunc<&pg_copy_logical_replication_slot_a>, true, false, TArgs_pg_copy_logical_replication_slot_a_Policy>; }
-struct TArgs_pg_copy_logical_replication_slot_b_Policy {
+TExecFunc arrow_pg_stat_get_xact_tuples_returned() { return TGenericExec<TPgDirectFunc<&pg_stat_get_xact_tuples_returned>, true, true, TArgs_pg_stat_get_xact_tuples_returned_Policy>({}); }
+struct TArgs_pg_stat_get_xact_tuples_updated_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_copy_logical_replication_slot_b() { return &GenericExec<TPgDirectFunc<&pg_copy_logical_replication_slot_b>, true, false, TArgs_pg_copy_logical_replication_slot_b_Policy>; }
-struct TArgs_pg_copy_logical_replication_slot_c_Policy {
+TExecFunc arrow_pg_stat_get_xact_tuples_updated() { return TGenericExec<TPgDirectFunc<&pg_stat_get_xact_tuples_updated>, true, true, TArgs_pg_stat_get_xact_tuples_updated_Policy>({}); }
+struct TArgs_pg_stat_reset_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_pg_copy_logical_replication_slot_c() { return &GenericExec<TPgDirectFunc<&pg_copy_logical_replication_slot_c>, true, false, TArgs_pg_copy_logical_replication_slot_c_Policy>; }
-struct TArgs_pg_copy_physical_replication_slot_a_Policy {
+TExecFunc arrow_pg_stat_reset() { return TGenericExec<TPgDirectFunc<&pg_stat_reset>, false, true, TArgs_pg_stat_reset_Policy>({}); }
+struct TArgs_pg_stat_reset_replication_slot_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_copy_physical_replication_slot_a() { return &GenericExec<TPgDirectFunc<&pg_copy_physical_replication_slot_a>, true, false, TArgs_pg_copy_physical_replication_slot_a_Policy>; }
-struct TArgs_pg_copy_physical_replication_slot_b_Policy {
+TExecFunc arrow_pg_stat_reset_replication_slot() { return TGenericExec<TPgDirectFunc<&pg_stat_reset_replication_slot>, false, true, TArgs_pg_stat_reset_replication_slot_Policy>({}); }
+struct TArgs_pg_stat_reset_shared_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_copy_physical_replication_slot_b() { return &GenericExec<TPgDirectFunc<&pg_copy_physical_replication_slot_b>, true, false, TArgs_pg_copy_physical_replication_slot_b_Policy>; }
-struct TArgs_pg_create_logical_replication_slot_Policy {
+TExecFunc arrow_pg_stat_reset_shared() { return TGenericExec<TPgDirectFunc<&pg_stat_reset_shared>, true, true, TArgs_pg_stat_reset_shared_Policy>({}); }
+struct TArgs_pg_stat_reset_single_function_counters_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,false,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_create_logical_replication_slot() { return &GenericExec<TPgDirectFunc<&pg_create_logical_replication_slot>, true, false, TArgs_pg_create_logical_replication_slot_Policy>; }
-struct TArgs_pg_create_physical_replication_slot_Policy {
+TExecFunc arrow_pg_stat_reset_single_function_counters() { return TGenericExec<TPgDirectFunc<&pg_stat_reset_single_function_counters>, true, true, TArgs_pg_stat_reset_single_function_counters_Policy>({}); }
+struct TArgs_pg_stat_reset_single_table_counters_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_create_physical_replication_slot() { return &GenericExec<TPgDirectFunc<&pg_create_physical_replication_slot>, true, false, TArgs_pg_create_physical_replication_slot_Policy>; }
-struct TArgs_pg_drop_replication_slot_Policy {
+TExecFunc arrow_pg_stat_reset_single_table_counters() { return TGenericExec<TPgDirectFunc<&pg_stat_reset_single_table_counters>, true, true, TArgs_pg_stat_reset_single_table_counters_Policy>({}); }
+struct TArgs_pg_stat_reset_slru_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_drop_replication_slot() { return &GenericExec<TPgDirectFunc<&pg_drop_replication_slot>, true, true, TArgs_pg_drop_replication_slot_Policy>; }
-struct TArgs_pg_encoding_max_length_sql_Policy {
+TExecFunc arrow_pg_stat_reset_slru() { return TGenericExec<TPgDirectFunc<&pg_stat_reset_slru>, false, true, TArgs_pg_stat_reset_slru_Policy>({}); }
+struct TArgs_pg_statistics_obj_is_visible_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_encoding_max_length_sql() { return &GenericExec<TPgDirectFunc<&pg_encoding_max_length_sql>, true, true, TArgs_pg_encoding_max_length_sql_Policy>; }
-struct TArgs_pg_event_trigger_table_rewrite_oid_Policy {
+TExecFunc arrow_pg_statistics_obj_is_visible() { return TGenericExec<TPgDirectFunc<&pg_statistics_obj_is_visible>, true, true, TArgs_pg_statistics_obj_is_visible_Policy>({}); }
+struct TArgs_pg_stop_backup_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_pg_event_trigger_table_rewrite_oid() { return &GenericExec<TPgDirectFunc<&pg_event_trigger_table_rewrite_oid>, true, true, TArgs_pg_event_trigger_table_rewrite_oid_Policy>; }
-struct TArgs_pg_event_trigger_table_rewrite_reason_Policy {
+TExecFunc arrow_pg_stop_backup() { return TGenericExec<TPgDirectFunc<&pg_stop_backup>, true, true, TArgs_pg_stop_backup_Policy>({}); }
+struct TArgs_pg_switch_wal_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_pg_event_trigger_table_rewrite_reason() { return &GenericExec<TPgDirectFunc<&pg_event_trigger_table_rewrite_reason>, true, true, TArgs_pg_event_trigger_table_rewrite_reason_Policy>; }
-struct TArgs_pg_extension_config_dump_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
-};
-TExecFunc arrow_pg_extension_config_dump() { return &GenericExec<TPgDirectFunc<&pg_extension_config_dump>, true, true, TArgs_pg_extension_config_dump_Policy>; }
-struct TArgs_pg_has_role_id_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
-};
-TExecFunc arrow_pg_has_role_id() { return &GenericExec<TPgDirectFunc<&pg_has_role_id>, true, true, TArgs_pg_has_role_id_Policy>; }
-struct TArgs_pg_has_role_id_id_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
-};
-TExecFunc arrow_pg_has_role_id_id() { return &GenericExec<TPgDirectFunc<&pg_has_role_id_id>, true, true, TArgs_pg_has_role_id_id_Policy>; }
-struct TArgs_pg_has_role_id_name_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
-};
-TExecFunc arrow_pg_has_role_id_name() { return &GenericExec<TPgDirectFunc<&pg_has_role_id_name>, true, true, TArgs_pg_has_role_id_name_Policy>; }
-struct TArgs_pg_has_role_name_Policy {
+TExecFunc arrow_pg_switch_wal() { return TGenericExec<TPgDirectFunc<&pg_switch_wal>, true, true, TArgs_pg_switch_wal_Policy>({}); }
+struct TArgs_pg_table_is_visible_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_has_role_name() { return &GenericExec<TPgDirectFunc<&pg_has_role_name>, true, true, TArgs_pg_has_role_name_Policy>; }
-struct TArgs_pg_has_role_name_id_Policy {
+TExecFunc arrow_pg_table_is_visible() { return TGenericExec<TPgDirectFunc<&pg_table_is_visible>, true, true, TArgs_pg_table_is_visible_Policy>({}); }
+struct TArgs_pg_table_size_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_has_role_name_id() { return &GenericExec<TPgDirectFunc<&pg_has_role_name_id>, true, true, TArgs_pg_has_role_name_id_Policy>; }
-struct TArgs_pg_has_role_name_name_Policy {
+TExecFunc arrow_pg_table_size() { return TGenericExec<TPgDirectFunc<&pg_table_size>, true, true, TArgs_pg_table_size_Policy>({}); }
+struct TArgs_pg_tablespace_size_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_has_role_name_name() { return &GenericExec<TPgDirectFunc<&pg_has_role_name_name>, true, true, TArgs_pg_has_role_name_name_Policy>; }
-struct TArgs_pg_nextoid_Policy {
+TExecFunc arrow_pg_tablespace_size_name() { return TGenericExec<TPgDirectFunc<&pg_tablespace_size_name>, true, true, TArgs_pg_tablespace_size_name_Policy>({}); }
+struct TArgs_pg_tablespace_size_oid_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_nextoid() { return &GenericExec<TPgDirectFunc<&pg_nextoid>, true, true, TArgs_pg_nextoid_Policy>; }
-struct TArgs_pg_replication_slot_advance_Policy {
+TExecFunc arrow_pg_tablespace_size_oid() { return TGenericExec<TPgDirectFunc<&pg_tablespace_size_oid>, true, true, TArgs_pg_tablespace_size_oid_Policy>({}); }
+struct TArgs_pg_total_relation_size_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_replication_slot_advance() { return &GenericExec<TPgDirectFunc<&pg_replication_slot_advance>, true, false, TArgs_pg_replication_slot_advance_Policy>; }
+TExecFunc arrow_pg_total_relation_size() { return TGenericExec<TPgDirectFunc<&pg_total_relation_size>, true, true, TArgs_pg_total_relation_size_Policy>({}); }
 struct TArgs_pg_trigger_depth_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_pg_trigger_depth() { return &GenericExec<TPgDirectFunc<&pg_trigger_depth>, true, true, TArgs_pg_trigger_depth_Policy>; }
-struct TArgs_pgsql_version_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
-};
-TExecFunc arrow_pgsql_version() { return &GenericExec<TPgDirectFunc<&pgsql_version>, true, false, TArgs_pgsql_version_Policy>; }
-struct TArgs_point_above_Policy {
+TExecFunc arrow_pg_trigger_depth() { return TGenericExec<TPgDirectFunc<&pg_trigger_depth>, true, true, TArgs_pg_trigger_depth_Policy>({}); }
+struct TArgs_pg_ts_config_is_visible_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_point_above() { return &GenericExec<TPgDirectFunc<&point_above>, true, true, TArgs_point_above_Policy>; }
-struct TArgs_point_add_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_point_add() { return &GenericExec<TPgDirectFunc<&point_add>, true, false, TArgs_point_add_Policy>; }
-struct TArgs_point_below_Policy {
+TExecFunc arrow_pg_ts_config_is_visible() { return TGenericExec<TPgDirectFunc<&pg_ts_config_is_visible>, true, true, TArgs_pg_ts_config_is_visible_Policy>({}); }
+struct TArgs_pg_ts_dict_is_visible_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_point_below() { return &GenericExec<TPgDirectFunc<&point_below>, true, true, TArgs_point_below_Policy>; }
-struct TArgs_point_box_Policy {
+TExecFunc arrow_pg_ts_dict_is_visible() { return TGenericExec<TPgDirectFunc<&pg_ts_dict_is_visible>, true, true, TArgs_pg_ts_dict_is_visible_Policy>({}); }
+struct TArgs_pg_ts_parser_is_visible_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_point_box() { return &GenericExec<TPgDirectFunc<&point_box>, true, false, TArgs_point_box_Policy>; }
-struct TArgs_point_distance_Policy {
+TExecFunc arrow_pg_ts_parser_is_visible() { return TGenericExec<TPgDirectFunc<&pg_ts_parser_is_visible>, true, true, TArgs_pg_ts_parser_is_visible_Policy>({}); }
+struct TArgs_pg_ts_template_is_visible_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_point_distance() { return &GenericExec<TPgDirectFunc<&point_distance>, true, true, TArgs_point_distance_Policy>; }
-struct TArgs_point_div_Policy {
+TExecFunc arrow_pg_ts_template_is_visible() { return TGenericExec<TPgDirectFunc<&pg_ts_template_is_visible>, true, true, TArgs_pg_ts_template_is_visible_Policy>({}); }
+struct TArgs_pg_type_is_visible_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_point_div() { return &GenericExec<TPgDirectFunc<&point_div>, true, false, TArgs_point_div_Policy>; }
-struct TArgs_point_eq_Policy {
+TExecFunc arrow_pg_type_is_visible() { return TGenericExec<TPgDirectFunc<&pg_type_is_visible>, true, true, TArgs_pg_type_is_visible_Policy>({}); }
+struct TArgs_pg_wal_lsn_diff_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_point_eq() { return &GenericExec<TPgDirectFunc<&point_eq>, true, true, TArgs_point_eq_Policy>; }
-struct TArgs_point_horiz_Policy {
+TExecFunc arrow_pg_wal_lsn_diff() { return TGenericExec<TPgDirectFunc<&pg_wal_lsn_diff>, true, false, TArgs_pg_wal_lsn_diff_Policy>({}); }
+struct TArgs_pg_wal_replay_pause_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_point_horiz() { return &GenericExec<TPgDirectFunc<&point_horiz>, true, true, TArgs_point_horiz_Policy>; }
-struct TArgs_point_in_Policy {
+TExecFunc arrow_pg_wal_replay_pause() { return TGenericExec<TPgDirectFunc<&pg_wal_replay_pause>, true, true, TArgs_pg_wal_replay_pause_Policy>({}); }
+struct TArgs_pg_wal_replay_resume_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_point_in() { return &GenericExec<TPgDirectFunc<&point_in>, true, false, TArgs_point_in_Policy>; }
-struct TArgs_point_left_Policy {
+TExecFunc arrow_pg_wal_replay_resume() { return TGenericExec<TPgDirectFunc<&pg_wal_replay_resume>, true, true, TArgs_pg_wal_replay_resume_Policy>({}); }
+struct TArgs_pg_walfile_name_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_point_left() { return &GenericExec<TPgDirectFunc<&point_left>, true, true, TArgs_point_left_Policy>; }
-struct TArgs_point_mul_Policy {
+TExecFunc arrow_pg_walfile_name() { return TGenericExec<TPgDirectFunc<&pg_walfile_name>, true, false, TArgs_pg_walfile_name_Policy>({}); }
+struct TArgs_pg_walfile_name_offset_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_point_mul() { return &GenericExec<TPgDirectFunc<&point_mul>, true, false, TArgs_point_mul_Policy>; }
-struct TArgs_point_ne_Policy {
+TExecFunc arrow_pg_walfile_name_offset() { return TGenericExec<TPgDirectFunc<&pg_walfile_name_offset>, true, false, TArgs_pg_walfile_name_offset_Policy>({}); }
+struct TArgs_prsd_end_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_point_ne() { return &GenericExec<TPgDirectFunc<&point_ne>, true, true, TArgs_point_ne_Policy>; }
-struct TArgs_point_out_Policy {
+TExecFunc arrow_prsd_end() { return TGenericExec<TPgDirectFunc<&prsd_end>, true, true, TArgs_prsd_end_Policy>({}); }
+struct TArgs_prsd_headline_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
 };
-TExecFunc arrow_point_out() { return &GenericExec<TPgDirectFunc<&point_out>, true, false, TArgs_point_out_Policy>; }
-struct TArgs_point_recv_Policy {
+TExecFunc arrow_prsd_headline() { return TGenericExec<TPgDirectFunc<&prsd_headline>, true, true, TArgs_prsd_headline_Policy>({}); }
+struct TArgs_prsd_lextype_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_point_recv() { return &GenericExec<TPgDirectFunc<&point_recv>, true, false, TArgs_point_recv_Policy>; }
-struct TArgs_point_right_Policy {
+TExecFunc arrow_prsd_lextype() { return TGenericExec<TPgDirectFunc<&prsd_lextype>, true, true, TArgs_prsd_lextype_Policy>({}); }
+struct TArgs_prsd_nexttoken_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_point_right() { return &GenericExec<TPgDirectFunc<&point_right>, true, true, TArgs_point_right_Policy>; }
-struct TArgs_point_send_Policy {
+TExecFunc arrow_prsd_nexttoken() { return TGenericExec<TPgDirectFunc<&prsd_nexttoken>, true, true, TArgs_prsd_nexttoken_Policy>({}); }
+struct TArgs_prsd_start_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_point_send() { return &GenericExec<TPgDirectFunc<&point_send>, true, false, TArgs_point_send_Policy>; }
-struct TArgs_point_slope_Policy {
+TExecFunc arrow_prsd_start() { return TGenericExec<TPgDirectFunc<&prsd_start>, true, true, TArgs_prsd_start_Policy>({}); }
+struct TArgs_radians_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_point_slope() { return &GenericExec<TPgDirectFunc<&point_slope>, true, true, TArgs_point_slope_Policy>; }
-struct TArgs_point_sub_Policy {
+TExecFunc arrow_radians() { return TGenericExec<TPgDirectFunc<&radians>, true, true, TArgs_radians_Policy>({}); }
+struct TArgs_range_adjacent_multirange_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_point_sub() { return &GenericExec<TPgDirectFunc<&point_sub>, true, false, TArgs_point_sub_Policy>; }
-struct TArgs_point_vert_Policy {
+TExecFunc arrow_range_adjacent_multirange() { return TGenericExec<TPgDirectFunc<&range_adjacent_multirange>, true, true, TArgs_range_adjacent_multirange_Policy>({}); }
+struct TArgs_range_after_multirange_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_point_vert() { return &GenericExec<TPgDirectFunc<&point_vert>, true, true, TArgs_point_vert_Policy>; }
-struct TArgs_points_box_Policy {
+TExecFunc arrow_range_after_multirange() { return TGenericExec<TPgDirectFunc<&range_after_multirange>, true, true, TArgs_range_after_multirange_Policy>({}); }
+struct TArgs_range_agg_finalfn_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_points_box() { return &GenericExec<TPgDirectFunc<&points_box>, true, false, TArgs_points_box_Policy>; }
-struct TArgs_poly_above_Policy {
+TExecFunc arrow_range_agg_finalfn() { return TGenericExec<TPgDirectFunc<&range_agg_finalfn>, false, false, TArgs_range_agg_finalfn_Policy>({}); }
+struct TArgs_range_agg_transfn_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_poly_above() { return &GenericExec<TPgDirectFunc<&poly_above>, true, true, TArgs_poly_above_Policy>; }
-struct TArgs_poly_below_Policy {
+TExecFunc arrow_range_agg_transfn() { return TGenericExec<TPgDirectFunc<&range_agg_transfn>, false, true, TArgs_range_agg_transfn_Policy>({}); }
+struct TArgs_range_before_multirange_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_poly_below() { return &GenericExec<TPgDirectFunc<&poly_below>, true, true, TArgs_poly_below_Policy>; }
-struct TArgs_poly_box_Policy {
+TExecFunc arrow_range_before_multirange() { return TGenericExec<TPgDirectFunc<&range_before_multirange>, true, true, TArgs_range_before_multirange_Policy>({}); }
+struct TArgs_range_contained_by_multirange_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_poly_box() { return &GenericExec<TPgDirectFunc<&poly_box>, true, false, TArgs_poly_box_Policy>; }
-struct TArgs_poly_center_Policy {
+TExecFunc arrow_range_contained_by_multirange() { return TGenericExec<TPgDirectFunc<&range_contained_by_multirange>, true, true, TArgs_range_contained_by_multirange_Policy>({}); }
+struct TArgs_range_contains_multirange_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_poly_center() { return &GenericExec<TPgDirectFunc<&poly_center>, true, false, TArgs_poly_center_Policy>; }
-struct TArgs_poly_circle_Policy {
+TExecFunc arrow_range_contains_multirange() { return TGenericExec<TPgDirectFunc<&range_contains_multirange>, true, true, TArgs_range_contains_multirange_Policy>({}); }
+struct TArgs_range_merge_from_multirange_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_poly_circle() { return &GenericExec<TPgDirectFunc<&poly_circle>, true, false, TArgs_poly_circle_Policy>; }
-struct TArgs_poly_contain_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_poly_contain() { return &GenericExec<TPgDirectFunc<&poly_contain>, true, true, TArgs_poly_contain_Policy>; }
-struct TArgs_poly_contain_pt_Policy {
+TExecFunc arrow_range_merge_from_multirange() { return TGenericExec<TPgDirectFunc<&range_merge_from_multirange>, true, false, TArgs_range_merge_from_multirange_Policy>({}); }
+struct TArgs_range_overlaps_multirange_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_poly_contain_pt() { return &GenericExec<TPgDirectFunc<&poly_contain_pt>, true, true, TArgs_poly_contain_pt_Policy>; }
-struct TArgs_poly_contained_Policy {
+TExecFunc arrow_range_overlaps_multirange() { return TGenericExec<TPgDirectFunc<&range_overlaps_multirange>, true, true, TArgs_range_overlaps_multirange_Policy>({}); }
+struct TArgs_range_overleft_multirange_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_poly_contained() { return &GenericExec<TPgDirectFunc<&poly_contained>, true, true, TArgs_poly_contained_Policy>; }
-struct TArgs_poly_distance_Policy {
+TExecFunc arrow_range_overleft_multirange() { return TGenericExec<TPgDirectFunc<&range_overleft_multirange>, true, true, TArgs_range_overleft_multirange_Policy>({}); }
+struct TArgs_range_overright_multirange_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_poly_distance() { return &GenericExec<TPgDirectFunc<&poly_distance>, true, true, TArgs_poly_distance_Policy>; }
-struct TArgs_poly_in_Policy {
+TExecFunc arrow_range_overright_multirange() { return TGenericExec<TPgDirectFunc<&range_overright_multirange>, true, true, TArgs_range_overright_multirange_Policy>({}); }
+struct TArgs_rangesel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_poly_in() { return &GenericExec<TPgDirectFunc<&poly_in>, true, false, TArgs_poly_in_Policy>; }
-struct TArgs_poly_left_Policy {
+TExecFunc arrow_rangesel() { return TGenericExec<TPgDirectFunc<&rangesel>, true, true, TArgs_rangesel_Policy>({}); }
+struct TArgs_record_eq_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_poly_left() { return &GenericExec<TPgDirectFunc<&poly_left>, true, true, TArgs_poly_left_Policy>; }
-struct TArgs_poly_npoints_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_poly_npoints() { return &GenericExec<TPgDirectFunc<&poly_npoints>, true, true, TArgs_poly_npoints_Policy>; }
-struct TArgs_poly_out_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_poly_out() { return &GenericExec<TPgDirectFunc<&poly_out>, true, false, TArgs_poly_out_Policy>; }
-struct TArgs_poly_overabove_Policy {
+TExecFunc arrow_record_eq() { return TGenericExec<TPgDirectFunc<&record_eq>, true, true, TArgs_record_eq_Policy>({}); }
+struct TArgs_record_ge_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_poly_overabove() { return &GenericExec<TPgDirectFunc<&poly_overabove>, true, true, TArgs_poly_overabove_Policy>; }
-struct TArgs_poly_overbelow_Policy {
+TExecFunc arrow_record_ge() { return TGenericExec<TPgDirectFunc<&record_ge>, true, true, TArgs_record_ge_Policy>({}); }
+struct TArgs_record_gt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_poly_overbelow() { return &GenericExec<TPgDirectFunc<&poly_overbelow>, true, true, TArgs_poly_overbelow_Policy>; }
-struct TArgs_poly_overlap_Policy {
+TExecFunc arrow_record_gt() { return TGenericExec<TPgDirectFunc<&record_gt>, true, true, TArgs_record_gt_Policy>({}); }
+struct TArgs_record_image_eq_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_poly_overlap() { return &GenericExec<TPgDirectFunc<&poly_overlap>, true, true, TArgs_poly_overlap_Policy>; }
-struct TArgs_poly_overleft_Policy {
+TExecFunc arrow_record_image_eq() { return TGenericExec<TPgDirectFunc<&record_image_eq>, true, true, TArgs_record_image_eq_Policy>({}); }
+struct TArgs_record_image_ge_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_poly_overleft() { return &GenericExec<TPgDirectFunc<&poly_overleft>, true, true, TArgs_poly_overleft_Policy>; }
-struct TArgs_poly_overright_Policy {
+TExecFunc arrow_record_image_ge() { return TGenericExec<TPgDirectFunc<&record_image_ge>, true, true, TArgs_record_image_ge_Policy>({}); }
+struct TArgs_record_image_gt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_poly_overright() { return &GenericExec<TPgDirectFunc<&poly_overright>, true, true, TArgs_poly_overright_Policy>; }
-struct TArgs_poly_path_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_poly_path() { return &GenericExec<TPgDirectFunc<&poly_path>, true, false, TArgs_poly_path_Policy>; }
-struct TArgs_poly_recv_Policy {
+TExecFunc arrow_record_image_gt() { return TGenericExec<TPgDirectFunc<&record_image_gt>, true, true, TArgs_record_image_gt_Policy>({}); }
+struct TArgs_record_image_le_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_poly_recv() { return &GenericExec<TPgDirectFunc<&poly_recv>, true, false, TArgs_poly_recv_Policy>; }
-struct TArgs_poly_right_Policy {
+TExecFunc arrow_record_image_le() { return TGenericExec<TPgDirectFunc<&record_image_le>, true, true, TArgs_record_image_le_Policy>({}); }
+struct TArgs_record_image_lt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_poly_right() { return &GenericExec<TPgDirectFunc<&poly_right>, true, true, TArgs_poly_right_Policy>; }
-struct TArgs_poly_same_Policy {
+TExecFunc arrow_record_image_lt() { return TGenericExec<TPgDirectFunc<&record_image_lt>, true, true, TArgs_record_image_lt_Policy>({}); }
+struct TArgs_record_image_ne_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_poly_same() { return &GenericExec<TPgDirectFunc<&poly_same>, true, true, TArgs_poly_same_Policy>; }
-struct TArgs_poly_send_Policy {
+TExecFunc arrow_record_image_ne() { return TGenericExec<TPgDirectFunc<&record_image_ne>, true, true, TArgs_record_image_ne_Policy>({}); }
+struct TArgs_record_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_poly_send() { return &GenericExec<TPgDirectFunc<&poly_send>, true, false, TArgs_poly_send_Policy>; }
-struct TArgs_pt_contained_circle_Policy {
+TExecFunc arrow_record_in() { return TGenericExec<TPgDirectFunc<&record_in>, true, false, TArgs_record_in_Policy>({}); }
+struct TArgs_record_le_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pt_contained_circle() { return &GenericExec<TPgDirectFunc<&pt_contained_circle>, true, true, TArgs_pt_contained_circle_Policy>; }
-struct TArgs_pt_contained_poly_Policy {
+TExecFunc arrow_record_le() { return TGenericExec<TPgDirectFunc<&record_le>, true, true, TArgs_record_le_Policy>({}); }
+struct TArgs_record_lt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pt_contained_poly() { return &GenericExec<TPgDirectFunc<&pt_contained_poly>, true, true, TArgs_pt_contained_poly_Policy>; }
-struct TArgs_quote_ident_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_quote_ident() { return &GenericExec<TPgDirectFunc<&quote_ident>, true, false, TArgs_quote_ident_Policy>; }
-struct TArgs_quote_literal_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_quote_literal() { return &GenericExec<TPgDirectFunc<&quote_literal>, true, false, TArgs_quote_literal_Policy>; }
-struct TArgs_quote_nullable_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_quote_nullable() { return &GenericExec<TPgDirectFunc<&quote_nullable>, false, false, TArgs_quote_nullable_Policy>; }
-struct TArgs_range_typanalyze_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_range_typanalyze() { return &GenericExec<TPgDirectFunc<&range_typanalyze>, true, true, TArgs_range_typanalyze_Policy>; }
-struct TArgs_repeat_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
-};
-TExecFunc arrow_repeat() { return &GenericExec<TPgDirectFunc<&repeat>, true, false, TArgs_repeat_Policy>; }
-struct TArgs_row_to_json_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
-};
-TExecFunc arrow_row_to_json() { return &GenericExec<TPgDirectFunc<&row_to_json>, true, false, TArgs_row_to_json_Policy>; }
-struct TArgs_row_to_json_pretty_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
-};
-TExecFunc arrow_row_to_json_pretty() { return &GenericExec<TPgDirectFunc<&row_to_json_pretty>, true, false, TArgs_row_to_json_pretty_Policy>; }
-struct TArgs_rpad_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
-};
-TExecFunc arrow_rpad() { return &GenericExec<TPgDirectFunc<&rpad>, true, false, TArgs_rpad_Policy>; }
-struct TArgs_rtrim_Policy {
+TExecFunc arrow_record_lt() { return TGenericExec<TPgDirectFunc<&record_lt>, true, true, TArgs_record_lt_Policy>({}); }
+struct TArgs_record_ne_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_rtrim() { return &GenericExec<TPgDirectFunc<&rtrim>, true, false, TArgs_rtrim_Policy>; }
-struct TArgs_rtrim1_Policy {
+TExecFunc arrow_record_ne() { return TGenericExec<TPgDirectFunc<&record_ne>, true, true, TArgs_record_ne_Policy>({}); }
+struct TArgs_record_out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_rtrim1() { return &GenericExec<TPgDirectFunc<&rtrim1>, true, false, TArgs_rtrim1_Policy>; }
-struct TArgs_scalargejoinsel_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
-};
-TExecFunc arrow_scalargejoinsel() { return &GenericExec<TPgDirectFunc<&scalargejoinsel>, true, true, TArgs_scalargejoinsel_Policy>; }
-struct TArgs_scalargesel_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
-};
-TExecFunc arrow_scalargesel() { return &GenericExec<TPgDirectFunc<&scalargesel>, true, true, TArgs_scalargesel_Policy>; }
-struct TArgs_scalargtjoinsel_Policy {
+TExecFunc arrow_record_out() { return TGenericExec<TPgDirectFunc<&record_out>, true, false, TArgs_record_out_Policy>({}); }
+struct TArgs_record_recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_scalargtjoinsel() { return &GenericExec<TPgDirectFunc<&scalargtjoinsel>, true, true, TArgs_scalargtjoinsel_Policy>; }
-struct TArgs_scalargtsel_Policy {
+TExecFunc arrow_record_recv() { return TGenericExec<TPgDirectFunc<&record_recv>, true, false, TArgs_record_recv_Policy>({}); }
+struct TArgs_record_send_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_scalargtsel() { return &GenericExec<TPgDirectFunc<&scalargtsel>, true, true, TArgs_scalargtsel_Policy>; }
-struct TArgs_scalarlejoinsel_Policy {
+TExecFunc arrow_record_send() { return TGenericExec<TPgDirectFunc<&record_send>, true, false, TArgs_record_send_Policy>({}); }
+struct TArgs_session_user_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_scalarlejoinsel() { return &GenericExec<TPgDirectFunc<&scalarlejoinsel>, true, true, TArgs_scalarlejoinsel_Policy>; }
-struct TArgs_scalarlesel_Policy {
+TExecFunc arrow_session_user() { return TGenericExec<TPgDirectFunc<&session_user>, true, false, TArgs_session_user_Policy>({}); }
+struct TArgs_setseed_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_scalarlesel() { return &GenericExec<TPgDirectFunc<&scalarlesel>, true, true, TArgs_scalarlesel_Policy>; }
-struct TArgs_scalarltjoinsel_Policy {
+TExecFunc arrow_setseed() { return TGenericExec<TPgDirectFunc<&setseed>, true, true, TArgs_setseed_Policy>({}); }
+struct TArgs_setval3_oid_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_scalarltjoinsel() { return &GenericExec<TPgDirectFunc<&scalarltjoinsel>, true, true, TArgs_scalarltjoinsel_Policy>; }
-struct TArgs_scalarltsel_Policy {
+TExecFunc arrow_setval3_oid() { return TGenericExec<TPgDirectFunc<&setval3_oid>, true, true, TArgs_setval3_oid_Policy>({}); }
+struct TArgs_setval_oid_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_scalarltsel() { return &GenericExec<TPgDirectFunc<&scalarltsel>, true, true, TArgs_scalarltsel_Policy>; }
-struct TArgs_set_config_by_name_Policy {
+TExecFunc arrow_setval_oid() { return TGenericExec<TPgDirectFunc<&setval_oid>, true, true, TArgs_setval_oid_Policy>({}); }
+struct TArgs_shell_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_set_config_by_name() { return &GenericExec<TPgDirectFunc<&set_config_by_name>, false, false, TArgs_set_config_by_name_Policy>; }
-struct TArgs_sha224_bytea_Policy {
+TExecFunc arrow_shell_in() { return TGenericExec<TPgDirectFunc<&shell_in>, false, true, TArgs_shell_in_Policy>({}); }
+struct TArgs_shell_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_sha224_bytea() { return &GenericExec<TPgDirectFunc<&sha224_bytea>, true, false, TArgs_sha224_bytea_Policy>; }
-struct TArgs_sha256_bytea_Policy {
+TExecFunc arrow_shell_out() { return TGenericExec<TPgDirectFunc<&shell_out>, true, false, TArgs_shell_out_Policy>({}); }
+struct TArgs_spg_kd_choose_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_sha256_bytea() { return &GenericExec<TPgDirectFunc<&sha256_bytea>, true, false, TArgs_sha256_bytea_Policy>; }
-struct TArgs_sha384_bytea_Policy {
+TExecFunc arrow_spg_kd_choose() { return TGenericExec<TPgDirectFunc<&spg_kd_choose>, true, true, TArgs_spg_kd_choose_Policy>({}); }
+struct TArgs_spg_kd_config_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_sha384_bytea() { return &GenericExec<TPgDirectFunc<&sha384_bytea>, true, false, TArgs_sha384_bytea_Policy>; }
-struct TArgs_sha512_bytea_Policy {
+TExecFunc arrow_spg_kd_config() { return TGenericExec<TPgDirectFunc<&spg_kd_config>, true, true, TArgs_spg_kd_config_Policy>({}); }
+struct TArgs_spg_kd_inner_consistent_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_sha512_bytea() { return &GenericExec<TPgDirectFunc<&sha512_bytea>, true, false, TArgs_sha512_bytea_Policy>; }
-struct TArgs_show_config_by_name_Policy {
+TExecFunc arrow_spg_kd_inner_consistent() { return TGenericExec<TPgDirectFunc<&spg_kd_inner_consistent>, true, true, TArgs_spg_kd_inner_consistent_Policy>({}); }
+struct TArgs_spg_kd_picksplit_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_show_config_by_name() { return &GenericExec<TPgDirectFunc<&show_config_by_name>, true, false, TArgs_show_config_by_name_Policy>; }
-struct TArgs_show_config_by_name_missing_ok_Policy {
+TExecFunc arrow_spg_kd_picksplit() { return TGenericExec<TPgDirectFunc<&spg_kd_picksplit>, true, true, TArgs_spg_kd_picksplit_Policy>({}); }
+struct TArgs_spg_quad_choose_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_show_config_by_name_missing_ok() { return &GenericExec<TPgDirectFunc<&show_config_by_name_missing_ok>, true, false, TArgs_show_config_by_name_missing_ok_Policy>; }
-struct TArgs_spg_kd_choose_Policy {
+TExecFunc arrow_spg_quad_choose() { return TGenericExec<TPgDirectFunc<&spg_quad_choose>, true, true, TArgs_spg_quad_choose_Policy>({}); }
+struct TArgs_spg_quad_config_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_spg_kd_choose() { return &GenericExec<TPgDirectFunc<&spg_kd_choose>, true, true, TArgs_spg_kd_choose_Policy>; }
-struct TArgs_spg_kd_config_Policy {
+TExecFunc arrow_spg_quad_config() { return TGenericExec<TPgDirectFunc<&spg_quad_config>, true, true, TArgs_spg_quad_config_Policy>({}); }
+struct TArgs_spg_quad_inner_consistent_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_spg_kd_config() { return &GenericExec<TPgDirectFunc<&spg_kd_config>, true, true, TArgs_spg_kd_config_Policy>; }
-struct TArgs_spg_kd_inner_consistent_Policy {
+TExecFunc arrow_spg_quad_inner_consistent() { return TGenericExec<TPgDirectFunc<&spg_quad_inner_consistent>, true, true, TArgs_spg_quad_inner_consistent_Policy>({}); }
+struct TArgs_spg_quad_leaf_consistent_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_spg_kd_inner_consistent() { return &GenericExec<TPgDirectFunc<&spg_kd_inner_consistent>, true, true, TArgs_spg_kd_inner_consistent_Policy>; }
-struct TArgs_spg_kd_picksplit_Policy {
+TExecFunc arrow_spg_quad_leaf_consistent() { return TGenericExec<TPgDirectFunc<&spg_quad_leaf_consistent>, true, true, TArgs_spg_quad_leaf_consistent_Policy>({}); }
+struct TArgs_spg_quad_picksplit_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_spg_kd_picksplit() { return &GenericExec<TPgDirectFunc<&spg_kd_picksplit>, true, true, TArgs_spg_kd_picksplit_Policy>; }
+TExecFunc arrow_spg_quad_picksplit() { return TGenericExec<TPgDirectFunc<&spg_quad_picksplit>, true, true, TArgs_spg_quad_picksplit_Policy>({}); }
 struct TArgs_spg_text_choose_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_spg_text_choose() { return &GenericExec<TPgDirectFunc<&spg_text_choose>, true, true, TArgs_spg_text_choose_Policy>; }
+TExecFunc arrow_spg_text_choose() { return TGenericExec<TPgDirectFunc<&spg_text_choose>, true, true, TArgs_spg_text_choose_Policy>({}); }
 struct TArgs_spg_text_config_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_spg_text_config() { return &GenericExec<TPgDirectFunc<&spg_text_config>, true, true, TArgs_spg_text_config_Policy>; }
+TExecFunc arrow_spg_text_config() { return TGenericExec<TPgDirectFunc<&spg_text_config>, true, true, TArgs_spg_text_config_Policy>({}); }
 struct TArgs_spg_text_inner_consistent_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_spg_text_inner_consistent() { return &GenericExec<TPgDirectFunc<&spg_text_inner_consistent>, true, true, TArgs_spg_text_inner_consistent_Policy>; }
+TExecFunc arrow_spg_text_inner_consistent() { return TGenericExec<TPgDirectFunc<&spg_text_inner_consistent>, true, true, TArgs_spg_text_inner_consistent_Policy>({}); }
 struct TArgs_spg_text_leaf_consistent_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_spg_text_leaf_consistent() { return &GenericExec<TPgDirectFunc<&spg_text_leaf_consistent>, true, true, TArgs_spg_text_leaf_consistent_Policy>; }
+TExecFunc arrow_spg_text_leaf_consistent() { return TGenericExec<TPgDirectFunc<&spg_text_leaf_consistent>, true, true, TArgs_spg_text_leaf_consistent_Policy>({}); }
 struct TArgs_spg_text_picksplit_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_spg_text_picksplit() { return &GenericExec<TPgDirectFunc<&spg_text_picksplit>, true, true, TArgs_spg_text_picksplit_Policy>; }
-struct TArgs_texticlike_Policy {
+TExecFunc arrow_spg_text_picksplit() { return TGenericExec<TPgDirectFunc<&spg_text_picksplit>, true, true, TArgs_spg_text_picksplit_Policy>({}); }
+struct TArgs_spghandler_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_texticlike() { return &GenericExec<TPgDirectFunc<&texticlike>, true, true, TArgs_texticlike_Policy>; }
-struct TArgs_texticnlike_Policy {
+TExecFunc arrow_spghandler() { return TGenericExec<TPgDirectFunc<&spghandler>, true, true, TArgs_spghandler_Policy>({}); }
+struct TArgs_suppress_redundant_updates_trigger_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_texticnlike() { return &GenericExec<TPgDirectFunc<&texticnlike>, true, true, TArgs_texticnlike_Policy>; }
-struct TArgs_textlike_Policy {
+TExecFunc arrow_suppress_redundant_updates_trigger() { return TGenericExec<TPgDirectFunc<&suppress_redundant_updates_trigger>, true, true, TArgs_suppress_redundant_updates_trigger_Policy>({}); }
+struct TArgs_table_am_handler_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_textlike() { return &GenericExec<TPgDirectFunc<&textlike>, true, true, TArgs_textlike_Policy>; }
-struct TArgs_textnlike_Policy {
+TExecFunc arrow_table_am_handler_in() { return TGenericExec<TPgDirectFunc<&table_am_handler_in>, false, true, TArgs_table_am_handler_in_Policy>({}); }
+struct TArgs_table_am_handler_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_textnlike() { return &GenericExec<TPgDirectFunc<&textnlike>, true, true, TArgs_textnlike_Policy>; }
-struct TArgs_timestamp_to_char_Policy {
+TExecFunc arrow_table_am_handler_out() { return TGenericExec<TPgDirectFunc<&table_am_handler_out>, true, false, TArgs_table_am_handler_out_Policy>({}); }
+struct TArgs_trigger_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_timestamp_to_char() { return &GenericExec<TPgDirectFunc<&timestamp_to_char>, true, false, TArgs_timestamp_to_char_Policy>; }
-struct TArgs_timestamptz_to_char_Policy {
+TExecFunc arrow_trigger_in() { return TGenericExec<TPgDirectFunc<&trigger_in>, false, true, TArgs_trigger_in_Policy>({}); }
+struct TArgs_trigger_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_timestamptz_to_char() { return &GenericExec<TPgDirectFunc<&timestamptz_to_char>, true, false, TArgs_timestamptz_to_char_Policy>; }
-struct TArgs_to_date_Policy {
+TExecFunc arrow_trigger_out() { return TGenericExec<TPgDirectFunc<&trigger_out>, true, false, TArgs_trigger_out_Policy>({}); }
+struct TArgs_tsm_handler_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_to_date() { return &GenericExec<TPgDirectFunc<&to_date>, true, true, TArgs_to_date_Policy>; }
-struct TArgs_to_json_Policy {
+TExecFunc arrow_tsm_handler_in() { return TGenericExec<TPgDirectFunc<&tsm_handler_in>, false, true, TArgs_tsm_handler_in_Policy>({}); }
+struct TArgs_tsm_handler_out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_to_json() { return &GenericExec<TPgDirectFunc<&to_json>, true, false, TArgs_to_json_Policy>; }
-struct TArgs_to_jsonb_Policy {
+TExecFunc arrow_tsm_handler_out() { return TGenericExec<TPgDirectFunc<&tsm_handler_out>, true, false, TArgs_tsm_handler_out_Policy>({}); }
+struct TArgs_tsm_system_handler_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_to_jsonb() { return &GenericExec<TPgDirectFunc<&to_jsonb>, true, false, TArgs_to_jsonb_Policy>; }
-struct TArgs_to_timestamp_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_to_timestamp() { return &GenericExec<TPgDirectFunc<&to_timestamp>, true, true, TArgs_to_timestamp_Policy>; }
-struct TArgs_translate_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
-};
-TExecFunc arrow_translate() { return &GenericExec<TPgDirectFunc<&translate>, true, false, TArgs_translate_Policy>; }
-struct TArgs_trim_array_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
-};
-TExecFunc arrow_trim_array() { return &GenericExec<TPgDirectFunc<&trim_array>, true, false, TArgs_trim_array_Policy>; }
-struct TArgs_ts_match_qv_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_ts_match_qv() { return &GenericExec<TPgDirectFunc<&ts_match_qv>, true, true, TArgs_ts_match_qv_Policy>; }
-struct TArgs_ts_match_tq_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_ts_match_tq() { return &GenericExec<TPgDirectFunc<&ts_match_tq>, true, true, TArgs_ts_match_tq_Policy>; }
-struct TArgs_ts_match_tt_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_ts_match_tt() { return &GenericExec<TPgDirectFunc<&ts_match_tt>, true, true, TArgs_ts_match_tt_Policy>; }
-struct TArgs_ts_match_vq_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_ts_match_vq() { return &GenericExec<TPgDirectFunc<&ts_match_vq>, true, true, TArgs_ts_match_vq_Policy>; }
-struct TArgs_tsmatchjoinsel_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
-};
-TExecFunc arrow_tsmatchjoinsel() { return &GenericExec<TPgDirectFunc<&tsmatchjoinsel>, true, true, TArgs_tsmatchjoinsel_Policy>; }
-struct TArgs_tsmatchsel_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
-};
-TExecFunc arrow_tsmatchsel() { return &GenericExec<TPgDirectFunc<&tsmatchsel>, true, true, TArgs_tsmatchsel_Policy>; }
+TExecFunc arrow_tsm_system_handler() { return TGenericExec<TPgDirectFunc<&tsm_system_handler>, true, true, TArgs_tsm_system_handler_Policy>({}); }
 struct TArgs_tsq_mcontained_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_tsq_mcontained() { return &GenericExec<TPgDirectFunc<&tsq_mcontained>, true, true, TArgs_tsq_mcontained_Policy>; }
+TExecFunc arrow_tsq_mcontained() { return TGenericExec<TPgDirectFunc<&tsq_mcontained>, true, true, TArgs_tsq_mcontained_Policy>({}); }
 struct TArgs_tsq_mcontains_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_tsq_mcontains() { return &GenericExec<TPgDirectFunc<&tsq_mcontains>, true, true, TArgs_tsq_mcontains_Policy>; }
+TExecFunc arrow_tsq_mcontains() { return TGenericExec<TPgDirectFunc<&tsq_mcontains>, true, true, TArgs_tsq_mcontains_Policy>({}); }
 struct TArgs_tsquery_and_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_tsquery_and() { return &GenericExec<TPgDirectFunc<&tsquery_and>, true, false, TArgs_tsquery_and_Policy>; }
+TExecFunc arrow_tsquery_and() { return TGenericExec<TPgDirectFunc<&tsquery_and>, true, false, TArgs_tsquery_and_Policy>({}); }
 struct TArgs_tsquery_cmp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_tsquery_cmp() { return &GenericExec<TPgDirectFunc<&tsquery_cmp>, true, true, TArgs_tsquery_cmp_Policy>; }
+TExecFunc arrow_tsquery_cmp() { return TGenericExec<TPgDirectFunc<&tsquery_cmp>, true, true, TArgs_tsquery_cmp_Policy>({}); }
 struct TArgs_tsquery_eq_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_tsquery_eq() { return &GenericExec<TPgDirectFunc<&tsquery_eq>, true, true, TArgs_tsquery_eq_Policy>; }
+TExecFunc arrow_tsquery_eq() { return TGenericExec<TPgDirectFunc<&tsquery_eq>, true, true, TArgs_tsquery_eq_Policy>({}); }
 struct TArgs_tsquery_ge_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_tsquery_ge() { return &GenericExec<TPgDirectFunc<&tsquery_ge>, true, true, TArgs_tsquery_ge_Policy>; }
+TExecFunc arrow_tsquery_ge() { return TGenericExec<TPgDirectFunc<&tsquery_ge>, true, true, TArgs_tsquery_ge_Policy>({}); }
 struct TArgs_tsquery_gt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_tsquery_gt() { return &GenericExec<TPgDirectFunc<&tsquery_gt>, true, true, TArgs_tsquery_gt_Policy>; }
+TExecFunc arrow_tsquery_gt() { return TGenericExec<TPgDirectFunc<&tsquery_gt>, true, true, TArgs_tsquery_gt_Policy>({}); }
 struct TArgs_tsquery_le_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_tsquery_le() { return &GenericExec<TPgDirectFunc<&tsquery_le>, true, true, TArgs_tsquery_le_Policy>; }
+TExecFunc arrow_tsquery_le() { return TGenericExec<TPgDirectFunc<&tsquery_le>, true, true, TArgs_tsquery_le_Policy>({}); }
 struct TArgs_tsquery_lt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_tsquery_lt() { return &GenericExec<TPgDirectFunc<&tsquery_lt>, true, true, TArgs_tsquery_lt_Policy>; }
+TExecFunc arrow_tsquery_lt() { return TGenericExec<TPgDirectFunc<&tsquery_lt>, true, true, TArgs_tsquery_lt_Policy>({}); }
 struct TArgs_tsquery_ne_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_tsquery_ne() { return &GenericExec<TPgDirectFunc<&tsquery_ne>, true, true, TArgs_tsquery_ne_Policy>; }
+TExecFunc arrow_tsquery_ne() { return TGenericExec<TPgDirectFunc<&tsquery_ne>, true, true, TArgs_tsquery_ne_Policy>({}); }
 struct TArgs_tsquery_not_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_tsquery_not() { return &GenericExec<TPgDirectFunc<&tsquery_not>, true, false, TArgs_tsquery_not_Policy>; }
+TExecFunc arrow_tsquery_not() { return TGenericExec<TPgDirectFunc<&tsquery_not>, true, false, TArgs_tsquery_not_Policy>({}); }
 struct TArgs_tsquery_numnode_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_tsquery_numnode() { return &GenericExec<TPgDirectFunc<&tsquery_numnode>, true, true, TArgs_tsquery_numnode_Policy>; }
+TExecFunc arrow_tsquery_numnode() { return TGenericExec<TPgDirectFunc<&tsquery_numnode>, true, true, TArgs_tsquery_numnode_Policy>({}); }
 struct TArgs_tsquery_or_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_tsquery_or() { return &GenericExec<TPgDirectFunc<&tsquery_or>, true, false, TArgs_tsquery_or_Policy>; }
+TExecFunc arrow_tsquery_or() { return TGenericExec<TPgDirectFunc<&tsquery_or>, true, false, TArgs_tsquery_or_Policy>({}); }
 struct TArgs_tsquery_phrase_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_tsquery_phrase() { return &GenericExec<TPgDirectFunc<&tsquery_phrase>, true, false, TArgs_tsquery_phrase_Policy>; }
+TExecFunc arrow_tsquery_phrase() { return TGenericExec<TPgDirectFunc<&tsquery_phrase>, true, false, TArgs_tsquery_phrase_Policy>({}); }
 struct TArgs_tsquery_phrase_distance_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {false,false,true};
 };
-TExecFunc arrow_tsquery_phrase_distance() { return &GenericExec<TPgDirectFunc<&tsquery_phrase_distance>, true, false, TArgs_tsquery_phrase_distance_Policy>; }
-struct TArgs_tsvector_cmp_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_tsvector_cmp() { return &GenericExec<TPgDirectFunc<&tsvector_cmp>, true, true, TArgs_tsvector_cmp_Policy>; }
-struct TArgs_tsvector_concat_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_tsvector_concat() { return &GenericExec<TPgDirectFunc<&tsvector_concat>, true, false, TArgs_tsvector_concat_Policy>; }
-struct TArgs_tsvector_delete_arr_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_tsvector_delete_arr() { return &GenericExec<TPgDirectFunc<&tsvector_delete_arr>, true, false, TArgs_tsvector_delete_arr_Policy>; }
-struct TArgs_tsvector_delete_str_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_tsvector_delete_str() { return &GenericExec<TPgDirectFunc<&tsvector_delete_str>, true, false, TArgs_tsvector_delete_str_Policy>; }
-struct TArgs_tsvector_eq_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_tsvector_eq() { return &GenericExec<TPgDirectFunc<&tsvector_eq>, true, true, TArgs_tsvector_eq_Policy>; }
-struct TArgs_tsvector_filter_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_tsvector_filter() { return &GenericExec<TPgDirectFunc<&tsvector_filter>, true, false, TArgs_tsvector_filter_Policy>; }
-struct TArgs_tsvector_ge_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_tsvector_ge() { return &GenericExec<TPgDirectFunc<&tsvector_ge>, true, true, TArgs_tsvector_ge_Policy>; }
-struct TArgs_tsvector_gt_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_tsvector_gt() { return &GenericExec<TPgDirectFunc<&tsvector_gt>, true, true, TArgs_tsvector_gt_Policy>; }
-struct TArgs_tsvector_le_Policy {
+TExecFunc arrow_tsquery_phrase_distance() { return TGenericExec<TPgDirectFunc<&tsquery_phrase_distance>, true, false, TArgs_tsquery_phrase_distance_Policy>({}); }
+struct TArgs_tsvectorin_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_tsvector_le() { return &GenericExec<TPgDirectFunc<&tsvector_le>, true, true, TArgs_tsvector_le_Policy>; }
-struct TArgs_tsvector_length_Policy {
+TExecFunc arrow_tsvectorin() { return TGenericExec<TPgDirectFunc<&tsvectorin>, true, false, TArgs_tsvectorin_Policy>({}); }
+struct TArgs_tsvectorout_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_tsvector_length() { return &GenericExec<TPgDirectFunc<&tsvector_length>, true, true, TArgs_tsvector_length_Policy>; }
-struct TArgs_tsvector_lt_Policy {
+TExecFunc arrow_tsvectorout() { return TGenericExec<TPgDirectFunc<&tsvectorout>, true, false, TArgs_tsvectorout_Policy>({}); }
+struct TArgs_tsvectorrecv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_tsvector_lt() { return &GenericExec<TPgDirectFunc<&tsvector_lt>, true, true, TArgs_tsvector_lt_Policy>; }
-struct TArgs_tsvector_ne_Policy {
+TExecFunc arrow_tsvectorrecv() { return TGenericExec<TPgDirectFunc<&tsvectorrecv>, true, false, TArgs_tsvectorrecv_Policy>({}); }
+struct TArgs_tsvectorsend_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_tsvector_ne() { return &GenericExec<TPgDirectFunc<&tsvector_ne>, true, true, TArgs_tsvector_ne_Policy>; }
-struct TArgs_tsvector_setweight_Policy {
+TExecFunc arrow_tsvectorsend() { return TGenericExec<TPgDirectFunc<&tsvectorsend>, true, false, TArgs_tsvectorsend_Policy>({}); }
+struct TArgs_varchar_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_tsvector_setweight() { return &GenericExec<TPgDirectFunc<&tsvector_setweight>, true, false, TArgs_tsvector_setweight_Policy>; }
-struct TArgs_tsvector_setweight_by_filter_Policy {
+TExecFunc arrow_varchar() { return TGenericExec<TPgDirectFunc<&varchar>, true, false, TArgs_varchar_Policy>({}); }
+struct TArgs_varchar_support_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_tsvector_setweight_by_filter() { return &GenericExec<TPgDirectFunc<&tsvector_setweight_by_filter>, true, false, TArgs_tsvector_setweight_by_filter_Policy>; }
-struct TArgs_tsvector_strip_Policy {
+TExecFunc arrow_varchar_support() { return TGenericExec<TPgDirectFunc<&varchar_support>, true, true, TArgs_varchar_support_Policy>({}); }
+struct TArgs_varcharin_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_tsvector_strip() { return &GenericExec<TPgDirectFunc<&tsvector_strip>, true, false, TArgs_tsvector_strip_Policy>; }
-struct TArgs_tsvector_to_array_Policy {
+TExecFunc arrow_varcharin() { return TGenericExec<TPgDirectFunc<&varcharin>, true, false, TArgs_varcharin_Policy>({}); }
+struct TArgs_varcharout_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_tsvector_to_array() { return &GenericExec<TPgDirectFunc<&tsvector_to_array>, true, false, TArgs_tsvector_to_array_Policy>; }
-struct TArgs_tsvector_update_trigger_bycolumn_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
-};
-TExecFunc arrow_tsvector_update_trigger_bycolumn() { return &GenericExec<TPgDirectFunc<&tsvector_update_trigger_bycolumn>, false, true, TArgs_tsvector_update_trigger_bycolumn_Policy>; }
-struct TArgs_tsvector_update_trigger_byid_Policy {
+TExecFunc arrow_varcharout() { return TGenericExec<TPgDirectFunc<&varcharout>, true, false, TArgs_varcharout_Policy>({}); }
+struct TArgs_varcharrecv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_tsvector_update_trigger_byid() { return &GenericExec<TPgDirectFunc<&tsvector_update_trigger_byid>, false, true, TArgs_tsvector_update_trigger_byid_Policy>; }
-struct TArgs_tsvectorin_Policy {
+TExecFunc arrow_varcharrecv() { return TGenericExec<TPgDirectFunc<&varcharrecv>, true, false, TArgs_varcharrecv_Policy>({}); }
+struct TArgs_varcharsend_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_tsvectorin() { return &GenericExec<TPgDirectFunc<&tsvectorin>, true, false, TArgs_tsvectorin_Policy>; }
-struct TArgs_tsvectorout_Policy {
+TExecFunc arrow_varcharsend() { return TGenericExec<TPgDirectFunc<&varcharsend>, true, false, TArgs_varcharsend_Policy>({}); }
+struct TArgs_varchartypmodin_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_tsvectorout() { return &GenericExec<TPgDirectFunc<&tsvectorout>, true, false, TArgs_tsvectorout_Policy>; }
-struct TArgs_tsvectorrecv_Policy {
+TExecFunc arrow_varchartypmodin() { return TGenericExec<TPgDirectFunc<&varchartypmodin>, true, true, TArgs_varchartypmodin_Policy>({}); }
+struct TArgs_varchartypmodout_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_tsvectorrecv() { return &GenericExec<TPgDirectFunc<&tsvectorrecv>, true, false, TArgs_tsvectorrecv_Policy>; }
-struct TArgs_tsvectorsend_Policy {
+TExecFunc arrow_varchartypmodout() { return TGenericExec<TPgDirectFunc<&varchartypmodout>, true, false, TArgs_varchartypmodout_Policy>({}); }
+struct TArgs_void_in_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_tsvectorsend() { return &GenericExec<TPgDirectFunc<&tsvectorsend>, true, false, TArgs_tsvectorsend_Policy>; }
-struct TArgs_upper_Policy {
+TExecFunc arrow_void_in() { return TGenericExec<TPgDirectFunc<&void_in>, true, true, TArgs_void_in_Policy>({}); }
+struct TArgs_void_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_upper() { return &GenericExec<TPgDirectFunc<&upper>, true, false, TArgs_upper_Policy>; }
-struct TArgs_uuid_cmp_Policy {
+TExecFunc arrow_void_out() { return TGenericExec<TPgDirectFunc<&void_out>, true, false, TArgs_void_out_Policy>({}); }
+struct TArgs_void_recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_uuid_cmp() { return &GenericExec<TPgDirectFunc<&uuid_cmp>, true, true, TArgs_uuid_cmp_Policy>; }
-struct TArgs_uuid_eq_Policy {
+TExecFunc arrow_void_recv() { return TGenericExec<TPgDirectFunc<&void_recv>, true, true, TArgs_void_recv_Policy>({}); }
+struct TArgs_void_send_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_uuid_eq() { return &GenericExec<TPgDirectFunc<&uuid_eq>, true, true, TArgs_uuid_eq_Policy>; }
-struct TArgs_uuid_ge_Policy {
+TExecFunc arrow_void_send() { return TGenericExec<TPgDirectFunc<&void_send>, true, false, TArgs_void_send_Policy>({}); }
+struct TArgs_width_bucket_float8_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_uuid_ge() { return &GenericExec<TPgDirectFunc<&uuid_ge>, true, true, TArgs_uuid_ge_Policy>; }
-struct TArgs_uuid_gt_Policy {
+TExecFunc arrow_width_bucket_float8() { return TGenericExec<TPgDirectFunc<&width_bucket_float8>, true, true, TArgs_width_bucket_float8_Policy>({}); }
+struct TArgs_xid8cmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_uuid_gt() { return &GenericExec<TPgDirectFunc<&uuid_gt>, true, true, TArgs_uuid_gt_Policy>; }
-struct TArgs_uuid_hash_Policy {
+TExecFunc arrow_xid8cmp() { return TGenericExec<TPgDirectFunc<&xid8cmp>, true, true, TArgs_xid8cmp_Policy>({}); }
+struct TArgs_xid8eq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_uuid_hash() { return &GenericExec<TPgDirectFunc<&uuid_hash>, true, true, TArgs_uuid_hash_Policy>; }
-struct TArgs_uuid_hash_extended_Policy {
+TExecFunc arrow_xid8eq() { return TGenericExec<TPgDirectFunc<&xid8eq>, true, true, TArgs_xid8eq_Policy>({}); }
+struct TArgs_xid8ge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_uuid_hash_extended() { return &GenericExec<TPgDirectFunc<&uuid_hash_extended>, true, true, TArgs_uuid_hash_extended_Policy>; }
-struct TArgs_uuid_in_Policy {
+TExecFunc arrow_xid8ge() { return TGenericExec<TPgDirectFunc<&xid8ge>, true, true, TArgs_xid8ge_Policy>({}); }
+struct TArgs_xid8gt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_uuid_in() { return &GenericExec<TPgDirectFunc<&uuid_in>, true, false, TArgs_uuid_in_Policy>; }
-struct TArgs_uuid_le_Policy {
+TExecFunc arrow_xid8gt() { return TGenericExec<TPgDirectFunc<&xid8gt>, true, true, TArgs_xid8gt_Policy>({}); }
+struct TArgs_xid8in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_uuid_le() { return &GenericExec<TPgDirectFunc<&uuid_le>, true, true, TArgs_uuid_le_Policy>; }
-struct TArgs_uuid_lt_Policy {
+TExecFunc arrow_xid8in() { return TGenericExec<TPgDirectFunc<&xid8in>, true, true, TArgs_xid8in_Policy>({}); }
+struct TArgs_xid8le_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_uuid_lt() { return &GenericExec<TPgDirectFunc<&uuid_lt>, true, true, TArgs_uuid_lt_Policy>; }
-struct TArgs_uuid_ne_Policy {
+TExecFunc arrow_xid8le() { return TGenericExec<TPgDirectFunc<&xid8le>, true, true, TArgs_xid8le_Policy>({}); }
+struct TArgs_xid8lt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_uuid_ne() { return &GenericExec<TPgDirectFunc<&uuid_ne>, true, true, TArgs_uuid_ne_Policy>; }
-struct TArgs_uuid_out_Policy {
+TExecFunc arrow_xid8lt() { return TGenericExec<TPgDirectFunc<&xid8lt>, true, true, TArgs_xid8lt_Policy>({}); }
+struct TArgs_xid8ne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_uuid_out() { return &GenericExec<TPgDirectFunc<&uuid_out>, true, false, TArgs_uuid_out_Policy>; }
-struct TArgs_uuid_recv_Policy {
+TExecFunc arrow_xid8ne() { return TGenericExec<TPgDirectFunc<&xid8ne>, true, true, TArgs_xid8ne_Policy>({}); }
+struct TArgs_xid8out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_uuid_recv() { return &GenericExec<TPgDirectFunc<&uuid_recv>, true, false, TArgs_uuid_recv_Policy>; }
-struct TArgs_uuid_send_Policy {
+TExecFunc arrow_xid8out() { return TGenericExec<TPgDirectFunc<&xid8out>, true, false, TArgs_xid8out_Policy>({}); }
+struct TArgs_xid8recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_uuid_send() { return &GenericExec<TPgDirectFunc<&uuid_send>, true, false, TArgs_uuid_send_Policy>; }
-struct TArgs_uuid_sortsupport_Policy {
+TExecFunc arrow_xid8recv() { return TGenericExec<TPgDirectFunc<&xid8recv>, true, true, TArgs_xid8recv_Policy>({}); }
+struct TArgs_xid8send_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_uuid_sortsupport() { return &GenericExec<TPgDirectFunc<&uuid_sortsupport>, true, true, TArgs_uuid_sortsupport_Policy>; }
-struct TArgs_varchar_Policy {
+TExecFunc arrow_xid8send() { return TGenericExec<TPgDirectFunc<&xid8send>, true, false, TArgs_xid8send_Policy>({}); }
+struct TArgs_xid8toxid_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_varchar() { return &GenericExec<TPgDirectFunc<&varchar>, true, false, TArgs_varchar_Policy>; }
-struct TArgs_varchar_support_Policy {
+TExecFunc arrow_xid8toxid() { return TGenericExec<TPgDirectFunc<&xid8toxid>, true, true, TArgs_xid8toxid_Policy>({}); }
+struct TArgs_xid_age_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_varchar_support() { return &GenericExec<TPgDirectFunc<&varchar_support>, true, true, TArgs_varchar_support_Policy>; }
-struct TArgs_varcharin_Policy {
+TExecFunc arrow_xid_age() { return TGenericExec<TPgDirectFunc<&xid_age>, true, true, TArgs_xid_age_Policy>({}); }
+struct TArgs_xideq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_varcharin() { return &GenericExec<TPgDirectFunc<&varcharin>, true, false, TArgs_varcharin_Policy>; }
-struct TArgs_varcharout_Policy {
+TExecFunc arrow_xideq() { return TGenericExec<TPgDirectFunc<&xideq>, true, true, TArgs_xideq_Policy>({}); }
+struct TArgs_xidin_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_varcharout() { return &GenericExec<TPgDirectFunc<&varcharout>, true, false, TArgs_varcharout_Policy>; }
-struct TArgs_varcharrecv_Policy {
+TExecFunc arrow_xidin() { return TGenericExec<TPgDirectFunc<&xidin>, true, true, TArgs_xidin_Policy>({}); }
+struct TArgs_xidneq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
-};
-TExecFunc arrow_varcharrecv() { return &GenericExec<TPgDirectFunc<&varcharrecv>, true, false, TArgs_varcharrecv_Policy>; }
-struct TArgs_varcharsend_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_varcharsend() { return &GenericExec<TPgDirectFunc<&varcharsend>, true, false, TArgs_varcharsend_Policy>; }
-struct TArgs_varchartypmodin_Policy {
+TExecFunc arrow_xidneq() { return TGenericExec<TPgDirectFunc<&xidneq>, true, true, TArgs_xidneq_Policy>({}); }
+struct TArgs_xidout_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_varchartypmodin() { return &GenericExec<TPgDirectFunc<&varchartypmodin>, true, true, TArgs_varchartypmodin_Policy>; }
-struct TArgs_varchartypmodout_Policy {
+TExecFunc arrow_xidout() { return TGenericExec<TPgDirectFunc<&xidout>, true, false, TArgs_xidout_Policy>({}); }
+struct TArgs_xidrecv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_varchartypmodout() { return &GenericExec<TPgDirectFunc<&varchartypmodout>, true, false, TArgs_varchartypmodout_Policy>; }
-struct TArgs_width_bucket_array_Policy {
+TExecFunc arrow_xidrecv() { return TGenericExec<TPgDirectFunc<&xidrecv>, true, true, TArgs_xidrecv_Policy>({}); }
+struct TArgs_xidsend_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_width_bucket_array() { return &GenericExec<TPgDirectFunc<&width_bucket_array>, true, true, TArgs_width_bucket_array_Policy>; }
+TExecFunc arrow_xidsend() { return TGenericExec<TPgDirectFunc<&xidsend>, true, false, TArgs_xidsend_Policy>({}); }
diff --git a/ydb/library/yql/parser/pg_wrapper/pg_kernels.3.cpp b/ydb/library/yql/parser/pg_wrapper/pg_kernels.3.cpp
index df090b764bc..c5a14e5197f 100644
--- a/ydb/library/yql/parser/pg_wrapper/pg_kernels.3.cpp
+++ b/ydb/library/yql/parser/pg_wrapper/pg_kernels.3.cpp
@@ -28,7 +28,11 @@ namespace NYql {
 
 extern "C" {
 
+#ifdef USE_SLOW_PG_KERNELS
+#include "pg_kernels.slow.3.inc"
+#else
 #include "pg_kernels.3.inc"
+#endif
 
 }
 
diff --git a/ydb/library/yql/parser/pg_wrapper/pg_kernels.3.inc b/ydb/library/yql/parser/pg_wrapper/pg_kernels.3.inc
index e330140e46e..83bbb52fc55 100644
--- a/ydb/library/yql/parser/pg_wrapper/pg_kernels.3.inc
+++ b/ydb/library/yql/parser/pg_wrapper/pg_kernels.3.inc
@@ -1,3375 +1,3660 @@
-struct TArgs_array_subscript_handler_Policy {
+struct TArgs_areajoinsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_array_subscript_handler() { return &GenericExec<TPgDirectFunc<&array_subscript_handler>, true, true, TArgs_array_subscript_handler_Policy>; }
-struct TArgs_array_to_text_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
-};
-TExecFunc arrow_array_to_text() { return &GenericExec<TPgDirectFunc<&array_to_text>, true, false, TArgs_array_to_text_Policy>; }
-struct TArgs_array_to_text_null_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
 };
-TExecFunc arrow_array_to_text_null() { return &GenericExec<TPgDirectFunc<&array_to_text_null>, false, false, TArgs_array_to_text_null_Policy>; }
-struct TArgs_binary_upgrade_create_empty_extension_Policy {
+TExecFunc arrow_areajoinsel() { return TGenericExec<TPgDirectFunc<&areajoinsel>, true, true, TArgs_areajoinsel_Policy>({}); }
+struct TArgs_areasel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 7> IsFixedArg = {false,false,true,false,false,false,false};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_binary_upgrade_create_empty_extension() { return &GenericExec<TPgDirectFunc<&binary_upgrade_create_empty_extension>, false, true, TArgs_binary_upgrade_create_empty_extension_Policy>; }
-struct TArgs_binary_upgrade_set_missing_value_Policy {
+TExecFunc arrow_areasel() { return TGenericExec<TPgDirectFunc<&areasel>, true, true, TArgs_areasel_Policy>({}); }
+struct TArgs_array_agg_array_finalfn_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_binary_upgrade_set_missing_value() { return &GenericExec<TPgDirectFunc<&binary_upgrade_set_missing_value>, true, true, TArgs_binary_upgrade_set_missing_value_Policy>; }
-struct TArgs_binary_upgrade_set_next_array_pg_type_oid_Policy {
+TExecFunc arrow_array_agg_array_finalfn() { return TGenericExec<TPgDirectFunc<&array_agg_array_finalfn>, false, false, TArgs_array_agg_array_finalfn_Policy>({}); }
+struct TArgs_array_agg_array_transfn_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_binary_upgrade_set_next_array_pg_type_oid() { return &GenericExec<TPgDirectFunc<&binary_upgrade_set_next_array_pg_type_oid>, true, true, TArgs_binary_upgrade_set_next_array_pg_type_oid_Policy>; }
-struct TArgs_binary_upgrade_set_next_heap_pg_class_oid_Policy {
+TExecFunc arrow_array_agg_array_transfn() { return TGenericExec<TPgDirectFunc<&array_agg_array_transfn>, false, true, TArgs_array_agg_array_transfn_Policy>({}); }
+struct TArgs_array_agg_finalfn_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_binary_upgrade_set_next_heap_pg_class_oid() { return &GenericExec<TPgDirectFunc<&binary_upgrade_set_next_heap_pg_class_oid>, true, true, TArgs_binary_upgrade_set_next_heap_pg_class_oid_Policy>; }
-struct TArgs_binary_upgrade_set_next_index_pg_class_oid_Policy {
+TExecFunc arrow_array_agg_finalfn() { return TGenericExec<TPgDirectFunc<&array_agg_finalfn>, false, false, TArgs_array_agg_finalfn_Policy>({}); }
+struct TArgs_array_agg_transfn_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_binary_upgrade_set_next_index_pg_class_oid() { return &GenericExec<TPgDirectFunc<&binary_upgrade_set_next_index_pg_class_oid>, true, true, TArgs_binary_upgrade_set_next_index_pg_class_oid_Policy>; }
-struct TArgs_binary_upgrade_set_next_multirange_array_pg_type_oid_Policy {
+TExecFunc arrow_array_agg_transfn() { return TGenericExec<TPgDirectFunc<&array_agg_transfn>, false, true, TArgs_array_agg_transfn_Policy>({}); }
+struct TArgs_array_append_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_binary_upgrade_set_next_multirange_array_pg_type_oid() { return &GenericExec<TPgDirectFunc<&binary_upgrade_set_next_multirange_array_pg_type_oid>, true, true, TArgs_binary_upgrade_set_next_multirange_array_pg_type_oid_Policy>; }
-struct TArgs_binary_upgrade_set_next_multirange_pg_type_oid_Policy {
+TExecFunc arrow_array_append() { return TGenericExec<TPgDirectFunc<&array_append>, false, false, TArgs_array_append_Policy>({}); }
+struct TArgs_array_cat_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_binary_upgrade_set_next_multirange_pg_type_oid() { return &GenericExec<TPgDirectFunc<&binary_upgrade_set_next_multirange_pg_type_oid>, true, true, TArgs_binary_upgrade_set_next_multirange_pg_type_oid_Policy>; }
-struct TArgs_binary_upgrade_set_next_pg_authid_oid_Policy {
+TExecFunc arrow_array_cat() { return TGenericExec<TPgDirectFunc<&array_cat>, false, false, TArgs_array_cat_Policy>({}); }
+struct TArgs_array_position_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_binary_upgrade_set_next_pg_authid_oid() { return &GenericExec<TPgDirectFunc<&binary_upgrade_set_next_pg_authid_oid>, true, true, TArgs_binary_upgrade_set_next_pg_authid_oid_Policy>; }
-struct TArgs_binary_upgrade_set_next_pg_enum_oid_Policy {
+TExecFunc arrow_array_position() { return TGenericExec<TPgDirectFunc<&array_position>, false, true, TArgs_array_position_Policy>({}); }
+struct TArgs_array_position_start_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_binary_upgrade_set_next_pg_enum_oid() { return &GenericExec<TPgDirectFunc<&binary_upgrade_set_next_pg_enum_oid>, true, true, TArgs_binary_upgrade_set_next_pg_enum_oid_Policy>; }
-struct TArgs_binary_upgrade_set_next_pg_type_oid_Policy {
+TExecFunc arrow_array_position_start() { return TGenericExec<TPgDirectFunc<&array_position_start>, false, true, TArgs_array_position_start_Policy>({}); }
+struct TArgs_array_positions_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_binary_upgrade_set_next_pg_type_oid() { return &GenericExec<TPgDirectFunc<&binary_upgrade_set_next_pg_type_oid>, true, true, TArgs_binary_upgrade_set_next_pg_type_oid_Policy>; }
-struct TArgs_binary_upgrade_set_next_toast_pg_class_oid_Policy {
+TExecFunc arrow_array_positions() { return TGenericExec<TPgDirectFunc<&array_positions>, false, false, TArgs_array_positions_Policy>({}); }
+struct TArgs_array_prepend_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_binary_upgrade_set_next_toast_pg_class_oid() { return &GenericExec<TPgDirectFunc<&binary_upgrade_set_next_toast_pg_class_oid>, true, true, TArgs_binary_upgrade_set_next_toast_pg_class_oid_Policy>; }
-struct TArgs_binary_upgrade_set_record_init_privs_Policy {
+TExecFunc arrow_array_prepend() { return TGenericExec<TPgDirectFunc<&array_prepend>, false, false, TArgs_array_prepend_Policy>({}); }
+struct TArgs_array_typanalyze_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_binary_upgrade_set_record_init_privs() { return &GenericExec<TPgDirectFunc<&binary_upgrade_set_record_init_privs>, true, true, TArgs_binary_upgrade_set_record_init_privs_Policy>; }
-struct TArgs_brin_bloom_add_value_Policy {
+TExecFunc arrow_array_typanalyze() { return TGenericExec<TPgDirectFunc<&array_typanalyze>, true, true, TArgs_array_typanalyze_Policy>({}); }
+struct TArgs_binary_decode_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_brin_bloom_add_value() { return &GenericExec<TPgDirectFunc<&brin_bloom_add_value>, true, true, TArgs_brin_bloom_add_value_Policy>; }
-struct TArgs_brin_bloom_consistent_Policy {
+TExecFunc arrow_binary_decode() { return TGenericExec<TPgDirectFunc<&binary_decode>, true, false, TArgs_binary_decode_Policy>({}); }
+struct TArgs_binary_encode_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_brin_bloom_consistent() { return &GenericExec<TPgDirectFunc<&brin_bloom_consistent>, true, true, TArgs_brin_bloom_consistent_Policy>; }
-struct TArgs_brin_bloom_opcinfo_Policy {
+TExecFunc arrow_binary_encode() { return TGenericExec<TPgDirectFunc<&binary_encode>, true, false, TArgs_binary_encode_Policy>({}); }
+struct TArgs_bit_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_brin_bloom_opcinfo() { return &GenericExec<TPgDirectFunc<&brin_bloom_opcinfo>, true, true, TArgs_brin_bloom_opcinfo_Policy>; }
-struct TArgs_brin_bloom_options_Policy {
+TExecFunc arrow_bit() { return TGenericExec<TPgDirectFunc<&bit>, true, false, TArgs_bit_Policy>({}); }
+struct TArgs_bit_and_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_brin_bloom_options() { return &GenericExec<TPgDirectFunc<&brin_bloom_options>, false, true, TArgs_brin_bloom_options_Policy>; }
-struct TArgs_brin_bloom_summary_in_Policy {
+TExecFunc arrow_bit_and() { return TGenericExec<TPgDirectFunc<&bit_and>, true, false, TArgs_bit_and_Policy>({}); }
+struct TArgs_bit_bit_count_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_brin_bloom_summary_in() { return &GenericExec<TPgDirectFunc<&brin_bloom_summary_in>, true, false, TArgs_brin_bloom_summary_in_Policy>; }
-struct TArgs_brin_bloom_summary_out_Policy {
+TExecFunc arrow_bit_bit_count() { return TGenericExec<TPgDirectFunc<&bit_bit_count>, true, true, TArgs_bit_bit_count_Policy>({}); }
+struct TArgs_bit_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_brin_bloom_summary_out() { return &GenericExec<TPgDirectFunc<&brin_bloom_summary_out>, true, false, TArgs_brin_bloom_summary_out_Policy>; }
-struct TArgs_brin_bloom_summary_recv_Policy {
+TExecFunc arrow_bit_in() { return TGenericExec<TPgDirectFunc<&bit_in>, true, false, TArgs_bit_in_Policy>({}); }
+struct TArgs_bit_or_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_brin_bloom_summary_recv() { return &GenericExec<TPgDirectFunc<&brin_bloom_summary_recv>, true, false, TArgs_brin_bloom_summary_recv_Policy>; }
-struct TArgs_brin_bloom_summary_send_Policy {
+TExecFunc arrow_bit_or() { return TGenericExec<TPgDirectFunc<&bit_or>, true, false, TArgs_bit_or_Policy>({}); }
+struct TArgs_bit_out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_brin_bloom_summary_send() { return &GenericExec<TPgDirectFunc<&brin_bloom_summary_send>, true, false, TArgs_brin_bloom_summary_send_Policy>; }
-struct TArgs_brin_bloom_union_Policy {
+TExecFunc arrow_bit_out() { return TGenericExec<TPgDirectFunc<&bit_out>, true, false, TArgs_bit_out_Policy>({}); }
+struct TArgs_bit_recv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_brin_bloom_union() { return &GenericExec<TPgDirectFunc<&brin_bloom_union>, true, true, TArgs_brin_bloom_union_Policy>; }
-struct TArgs_brin_inclusion_add_value_Policy {
+TExecFunc arrow_bit_recv() { return TGenericExec<TPgDirectFunc<&bit_recv>, true, false, TArgs_bit_recv_Policy>({}); }
+struct TArgs_bit_send_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
-};
-TExecFunc arrow_brin_inclusion_add_value() { return &GenericExec<TPgDirectFunc<&brin_inclusion_add_value>, true, true, TArgs_brin_inclusion_add_value_Policy>; }
-struct TArgs_brin_inclusion_consistent_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_brin_inclusion_consistent() { return &GenericExec<TPgDirectFunc<&brin_inclusion_consistent>, true, true, TArgs_brin_inclusion_consistent_Policy>; }
-struct TArgs_brin_inclusion_opcinfo_Policy {
+TExecFunc arrow_bit_send() { return TGenericExec<TPgDirectFunc<&bit_send>, true, false, TArgs_bit_send_Policy>({}); }
+struct TArgs_bitcat_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_brin_inclusion_opcinfo() { return &GenericExec<TPgDirectFunc<&brin_inclusion_opcinfo>, true, true, TArgs_brin_inclusion_opcinfo_Policy>; }
-struct TArgs_brin_inclusion_union_Policy {
+TExecFunc arrow_bitcat() { return TGenericExec<TPgDirectFunc<&bitcat>, true, false, TArgs_bitcat_Policy>({}); }
+struct TArgs_bitcmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_brin_inclusion_union() { return &GenericExec<TPgDirectFunc<&brin_inclusion_union>, true, true, TArgs_brin_inclusion_union_Policy>; }
-struct TArgs_brin_minmax_multi_add_value_Policy {
+TExecFunc arrow_bitcmp() { return TGenericExec<TPgDirectFunc<&bitcmp>, true, true, TArgs_bitcmp_Policy>({}); }
+struct TArgs_biteq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_brin_minmax_multi_add_value() { return &GenericExec<TPgDirectFunc<&brin_minmax_multi_add_value>, true, true, TArgs_brin_minmax_multi_add_value_Policy>; }
-struct TArgs_brin_minmax_multi_consistent_Policy {
+TExecFunc arrow_biteq() { return TGenericExec<TPgDirectFunc<&biteq>, true, true, TArgs_biteq_Policy>({}); }
+struct TArgs_bitfromint4_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_brin_minmax_multi_consistent() { return &GenericExec<TPgDirectFunc<&brin_minmax_multi_consistent>, true, true, TArgs_brin_minmax_multi_consistent_Policy>; }
-struct TArgs_brin_minmax_multi_distance_date_Policy {
+TExecFunc arrow_bitfromint4() { return TGenericExec<TPgDirectFunc<&bitfromint4>, true, false, TArgs_bitfromint4_Policy>({}); }
+struct TArgs_bitfromint8_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_brin_minmax_multi_distance_date() { return &GenericExec<TPgDirectFunc<&brin_minmax_multi_distance_date>, true, true, TArgs_brin_minmax_multi_distance_date_Policy>; }
-struct TArgs_brin_minmax_multi_distance_float4_Policy {
+TExecFunc arrow_bitfromint8() { return TGenericExec<TPgDirectFunc<&bitfromint8>, true, false, TArgs_bitfromint8_Policy>({}); }
+struct TArgs_bitge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_brin_minmax_multi_distance_float4() { return &GenericExec<TPgDirectFunc<&brin_minmax_multi_distance_float4>, true, true, TArgs_brin_minmax_multi_distance_float4_Policy>; }
-struct TArgs_brin_minmax_multi_distance_float8_Policy {
+TExecFunc arrow_bitge() { return TGenericExec<TPgDirectFunc<&bitge>, true, true, TArgs_bitge_Policy>({}); }
+struct TArgs_bitgetbit_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_brin_minmax_multi_distance_float8() { return &GenericExec<TPgDirectFunc<&brin_minmax_multi_distance_float8>, true, true, TArgs_brin_minmax_multi_distance_float8_Policy>; }
-struct TArgs_brin_minmax_multi_distance_inet_Policy {
+TExecFunc arrow_bitgetbit() { return TGenericExec<TPgDirectFunc<&bitgetbit>, true, true, TArgs_bitgetbit_Policy>({}); }
+struct TArgs_bitgt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_brin_minmax_multi_distance_inet() { return &GenericExec<TPgDirectFunc<&brin_minmax_multi_distance_inet>, true, true, TArgs_brin_minmax_multi_distance_inet_Policy>; }
-struct TArgs_brin_minmax_multi_distance_int2_Policy {
+TExecFunc arrow_bitgt() { return TGenericExec<TPgDirectFunc<&bitgt>, true, true, TArgs_bitgt_Policy>({}); }
+struct TArgs_bitle_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_brin_minmax_multi_distance_int2() { return &GenericExec<TPgDirectFunc<&brin_minmax_multi_distance_int2>, true, true, TArgs_brin_minmax_multi_distance_int2_Policy>; }
-struct TArgs_brin_minmax_multi_distance_int4_Policy {
+TExecFunc arrow_bitle() { return TGenericExec<TPgDirectFunc<&bitle>, true, true, TArgs_bitle_Policy>({}); }
+struct TArgs_bitlength_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_brin_minmax_multi_distance_int4() { return &GenericExec<TPgDirectFunc<&brin_minmax_multi_distance_int4>, true, true, TArgs_brin_minmax_multi_distance_int4_Policy>; }
-struct TArgs_brin_minmax_multi_distance_int8_Policy {
+TExecFunc arrow_bitlength() { return TGenericExec<TPgDirectFunc<&bitlength>, true, true, TArgs_bitlength_Policy>({}); }
+struct TArgs_bitlt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_brin_minmax_multi_distance_int8() { return &GenericExec<TPgDirectFunc<&brin_minmax_multi_distance_int8>, true, true, TArgs_brin_minmax_multi_distance_int8_Policy>; }
-struct TArgs_brin_minmax_multi_distance_interval_Policy {
+TExecFunc arrow_bitlt() { return TGenericExec<TPgDirectFunc<&bitlt>, true, true, TArgs_bitlt_Policy>({}); }
+struct TArgs_bitne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_brin_minmax_multi_distance_interval() { return &GenericExec<TPgDirectFunc<&brin_minmax_multi_distance_interval>, true, true, TArgs_brin_minmax_multi_distance_interval_Policy>; }
-struct TArgs_brin_minmax_multi_distance_macaddr_Policy {
+TExecFunc arrow_bitne() { return TGenericExec<TPgDirectFunc<&bitne>, true, true, TArgs_bitne_Policy>({}); }
+struct TArgs_bitnot_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_brin_minmax_multi_distance_macaddr() { return &GenericExec<TPgDirectFunc<&brin_minmax_multi_distance_macaddr>, true, true, TArgs_brin_minmax_multi_distance_macaddr_Policy>; }
-struct TArgs_brin_minmax_multi_distance_macaddr8_Policy {
+TExecFunc arrow_bitnot() { return TGenericExec<TPgDirectFunc<&bitnot>, true, false, TArgs_bitnot_Policy>({}); }
+struct TArgs_bitoctetlength_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_brin_minmax_multi_distance_macaddr8() { return &GenericExec<TPgDirectFunc<&brin_minmax_multi_distance_macaddr8>, true, true, TArgs_brin_minmax_multi_distance_macaddr8_Policy>; }
-struct TArgs_brin_minmax_multi_distance_numeric_Policy {
+TExecFunc arrow_bitoctetlength() { return TGenericExec<TPgDirectFunc<&bitoctetlength>, true, true, TArgs_bitoctetlength_Policy>({}); }
+struct TArgs_bitoverlay_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,false,true,true};
 };
-TExecFunc arrow_brin_minmax_multi_distance_numeric() { return &GenericExec<TPgDirectFunc<&brin_minmax_multi_distance_numeric>, true, true, TArgs_brin_minmax_multi_distance_numeric_Policy>; }
-struct TArgs_brin_minmax_multi_distance_pg_lsn_Policy {
+TExecFunc arrow_bitoverlay() { return TGenericExec<TPgDirectFunc<&bitoverlay>, true, false, TArgs_bitoverlay_Policy>({}); }
+struct TArgs_bitoverlay_no_len_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,true};
 };
-TExecFunc arrow_brin_minmax_multi_distance_pg_lsn() { return &GenericExec<TPgDirectFunc<&brin_minmax_multi_distance_pg_lsn>, true, true, TArgs_brin_minmax_multi_distance_pg_lsn_Policy>; }
-struct TArgs_brin_minmax_multi_distance_tid_Policy {
+TExecFunc arrow_bitoverlay_no_len() { return TGenericExec<TPgDirectFunc<&bitoverlay_no_len>, true, false, TArgs_bitoverlay_no_len_Policy>({}); }
+struct TArgs_bitposition_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_brin_minmax_multi_distance_tid() { return &GenericExec<TPgDirectFunc<&brin_minmax_multi_distance_tid>, true, true, TArgs_brin_minmax_multi_distance_tid_Policy>; }
-struct TArgs_brin_minmax_multi_distance_time_Policy {
+TExecFunc arrow_bitposition() { return TGenericExec<TPgDirectFunc<&bitposition>, true, true, TArgs_bitposition_Policy>({}); }
+struct TArgs_bitsetbit_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_brin_minmax_multi_distance_time() { return &GenericExec<TPgDirectFunc<&brin_minmax_multi_distance_time>, true, true, TArgs_brin_minmax_multi_distance_time_Policy>; }
-struct TArgs_brin_minmax_multi_distance_timestamp_Policy {
+TExecFunc arrow_bitsetbit() { return TGenericExec<TPgDirectFunc<&bitsetbit>, true, false, TArgs_bitsetbit_Policy>({}); }
+struct TArgs_bitshiftleft_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_brin_minmax_multi_distance_timestamp() { return &GenericExec<TPgDirectFunc<&brin_minmax_multi_distance_timestamp>, true, true, TArgs_brin_minmax_multi_distance_timestamp_Policy>; }
-struct TArgs_brin_minmax_multi_distance_timetz_Policy {
+TExecFunc arrow_bitshiftleft() { return TGenericExec<TPgDirectFunc<&bitshiftleft>, true, false, TArgs_bitshiftleft_Policy>({}); }
+struct TArgs_bitshiftright_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_brin_minmax_multi_distance_timetz() { return &GenericExec<TPgDirectFunc<&brin_minmax_multi_distance_timetz>, true, true, TArgs_brin_minmax_multi_distance_timetz_Policy>; }
-struct TArgs_brin_minmax_multi_distance_uuid_Policy {
+TExecFunc arrow_bitshiftright() { return TGenericExec<TPgDirectFunc<&bitshiftright>, true, false, TArgs_bitshiftright_Policy>({}); }
+struct TArgs_bitsubstr_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_brin_minmax_multi_distance_uuid() { return &GenericExec<TPgDirectFunc<&brin_minmax_multi_distance_uuid>, true, true, TArgs_brin_minmax_multi_distance_uuid_Policy>; }
-struct TArgs_brin_minmax_multi_opcinfo_Policy {
+TExecFunc arrow_bitsubstr() { return TGenericExec<TPgDirectFunc<&bitsubstr>, true, false, TArgs_bitsubstr_Policy>({}); }
+struct TArgs_bitsubstr_no_len_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_brin_minmax_multi_opcinfo() { return &GenericExec<TPgDirectFunc<&brin_minmax_multi_opcinfo>, true, true, TArgs_brin_minmax_multi_opcinfo_Policy>; }
-struct TArgs_brin_minmax_multi_options_Policy {
+TExecFunc arrow_bitsubstr_no_len() { return TGenericExec<TPgDirectFunc<&bitsubstr_no_len>, true, false, TArgs_bitsubstr_no_len_Policy>({}); }
+struct TArgs_bittoint4_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_brin_minmax_multi_options() { return &GenericExec<TPgDirectFunc<&brin_minmax_multi_options>, false, true, TArgs_brin_minmax_multi_options_Policy>; }
-struct TArgs_brin_minmax_multi_summary_in_Policy {
+TExecFunc arrow_bittoint4() { return TGenericExec<TPgDirectFunc<&bittoint4>, true, true, TArgs_bittoint4_Policy>({}); }
+struct TArgs_bittoint8_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_brin_minmax_multi_summary_in() { return &GenericExec<TPgDirectFunc<&brin_minmax_multi_summary_in>, true, false, TArgs_brin_minmax_multi_summary_in_Policy>; }
-struct TArgs_brin_minmax_multi_summary_out_Policy {
+TExecFunc arrow_bittoint8() { return TGenericExec<TPgDirectFunc<&bittoint8>, true, true, TArgs_bittoint8_Policy>({}); }
+struct TArgs_bittypmodin_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_brin_minmax_multi_summary_out() { return &GenericExec<TPgDirectFunc<&brin_minmax_multi_summary_out>, true, false, TArgs_brin_minmax_multi_summary_out_Policy>; }
-struct TArgs_brin_minmax_multi_summary_recv_Policy {
+TExecFunc arrow_bittypmodin() { return TGenericExec<TPgDirectFunc<&bittypmodin>, true, true, TArgs_bittypmodin_Policy>({}); }
+struct TArgs_bittypmodout_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_brin_minmax_multi_summary_recv() { return &GenericExec<TPgDirectFunc<&brin_minmax_multi_summary_recv>, true, false, TArgs_brin_minmax_multi_summary_recv_Policy>; }
-struct TArgs_brin_minmax_multi_summary_send_Policy {
+TExecFunc arrow_bittypmodout() { return TGenericExec<TPgDirectFunc<&bittypmodout>, true, false, TArgs_bittypmodout_Policy>({}); }
+struct TArgs_bitxor_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_brin_minmax_multi_summary_send() { return &GenericExec<TPgDirectFunc<&brin_minmax_multi_summary_send>, true, false, TArgs_brin_minmax_multi_summary_send_Policy>; }
-struct TArgs_brin_minmax_multi_union_Policy {
+TExecFunc arrow_bitxor() { return TGenericExec<TPgDirectFunc<&bitxor>, true, false, TArgs_bitxor_Policy>({}); }
+struct TArgs_box_above_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_brin_minmax_multi_union() { return &GenericExec<TPgDirectFunc<&brin_minmax_multi_union>, true, true, TArgs_brin_minmax_multi_union_Policy>; }
-struct TArgs_btequalimage_Policy {
+TExecFunc arrow_box_above() { return TGenericExec<TPgDirectFunc<&box_above>, true, true, TArgs_box_above_Policy>({}); }
+struct TArgs_box_above_eq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_btequalimage() { return &GenericExec<TPgDirectFunc<&btequalimage>, true, true, TArgs_btequalimage_Policy>; }
-struct TArgs_btfloat48cmp_Policy {
+TExecFunc arrow_box_above_eq() { return TGenericExec<TPgDirectFunc<&box_above_eq>, true, true, TArgs_box_above_eq_Policy>({}); }
+struct TArgs_box_add_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_btfloat48cmp() { return &GenericExec<TPgDirectFunc<&btfloat48cmp>, true, true, TArgs_btfloat48cmp_Policy>; }
-struct TArgs_btfloat4cmp_Policy {
+TExecFunc arrow_box_add() { return TGenericExec<TPgDirectFunc<&box_add>, true, false, TArgs_box_add_Policy>({}); }
+struct TArgs_box_area_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_btfloat4cmp() { return &GenericExec<TPgDirectFunc<&btfloat4cmp>, true, true, TArgs_btfloat4cmp_Policy>; }
-struct TArgs_btfloat4sortsupport_Policy {
+TExecFunc arrow_box_area() { return TGenericExec<TPgDirectFunc<&box_area>, true, true, TArgs_box_area_Policy>({}); }
+struct TArgs_box_below_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_btfloat4sortsupport() { return &GenericExec<TPgDirectFunc<&btfloat4sortsupport>, true, true, TArgs_btfloat4sortsupport_Policy>; }
-struct TArgs_btfloat84cmp_Policy {
+TExecFunc arrow_box_below() { return TGenericExec<TPgDirectFunc<&box_below>, true, true, TArgs_box_below_Policy>({}); }
+struct TArgs_box_below_eq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_btfloat84cmp() { return &GenericExec<TPgDirectFunc<&btfloat84cmp>, true, true, TArgs_btfloat84cmp_Policy>; }
-struct TArgs_btfloat8cmp_Policy {
+TExecFunc arrow_box_below_eq() { return TGenericExec<TPgDirectFunc<&box_below_eq>, true, true, TArgs_box_below_eq_Policy>({}); }
+struct TArgs_box_center_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_btfloat8cmp() { return &GenericExec<TPgDirectFunc<&btfloat8cmp>, true, true, TArgs_btfloat8cmp_Policy>; }
-struct TArgs_btfloat8sortsupport_Policy {
+TExecFunc arrow_box_center() { return TGenericExec<TPgDirectFunc<&box_center>, true, false, TArgs_box_center_Policy>({}); }
+struct TArgs_box_circle_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_btfloat8sortsupport() { return &GenericExec<TPgDirectFunc<&btfloat8sortsupport>, true, true, TArgs_btfloat8sortsupport_Policy>; }
-struct TArgs_bthandler_Policy {
+TExecFunc arrow_box_circle() { return TGenericExec<TPgDirectFunc<&box_circle>, true, false, TArgs_box_circle_Policy>({}); }
+struct TArgs_box_contain_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_bthandler() { return &GenericExec<TPgDirectFunc<&bthandler>, true, true, TArgs_bthandler_Policy>; }
-struct TArgs_btnametextcmp_Policy {
+TExecFunc arrow_box_contain() { return TGenericExec<TPgDirectFunc<&box_contain>, true, true, TArgs_box_contain_Policy>({}); }
+struct TArgs_box_contain_pt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_btnametextcmp() { return &GenericExec<TPgDirectFunc<&btnametextcmp>, true, true, TArgs_btnametextcmp_Policy>; }
-struct TArgs_bttext_pattern_cmp_Policy {
+TExecFunc arrow_box_contain_pt() { return TGenericExec<TPgDirectFunc<&box_contain_pt>, true, true, TArgs_box_contain_pt_Policy>({}); }
+struct TArgs_box_contained_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_bttext_pattern_cmp() { return &GenericExec<TPgDirectFunc<&bttext_pattern_cmp>, true, true, TArgs_bttext_pattern_cmp_Policy>; }
-struct TArgs_bttext_pattern_sortsupport_Policy {
+TExecFunc arrow_box_contained() { return TGenericExec<TPgDirectFunc<&box_contained>, true, true, TArgs_box_contained_Policy>({}); }
+struct TArgs_box_diagonal_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_bttext_pattern_sortsupport() { return &GenericExec<TPgDirectFunc<&bttext_pattern_sortsupport>, true, true, TArgs_bttext_pattern_sortsupport_Policy>; }
-struct TArgs_bttextcmp_Policy {
+TExecFunc arrow_box_diagonal() { return TGenericExec<TPgDirectFunc<&box_diagonal>, true, false, TArgs_box_diagonal_Policy>({}); }
+struct TArgs_box_distance_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_bttextcmp() { return &GenericExec<TPgDirectFunc<&bttextcmp>, true, true, TArgs_bttextcmp_Policy>; }
-struct TArgs_bttextnamecmp_Policy {
+TExecFunc arrow_box_distance() { return TGenericExec<TPgDirectFunc<&box_distance>, true, true, TArgs_box_distance_Policy>({}); }
+struct TArgs_box_div_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_bttextnamecmp() { return &GenericExec<TPgDirectFunc<&bttextnamecmp>, true, true, TArgs_bttextnamecmp_Policy>; }
-struct TArgs_bttextsortsupport_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
-};
-TExecFunc arrow_bttextsortsupport() { return &GenericExec<TPgDirectFunc<&bttextsortsupport>, true, true, TArgs_bttextsortsupport_Policy>; }
-struct TArgs_btvarstrequalimage_Policy {
+TExecFunc arrow_box_div() { return TGenericExec<TPgDirectFunc<&box_div>, true, false, TArgs_box_div_Policy>({}); }
+struct TArgs_box_eq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_btvarstrequalimage() { return &GenericExec<TPgDirectFunc<&btvarstrequalimage>, true, true, TArgs_btvarstrequalimage_Policy>; }
-struct TArgs_byteaGetBit_Policy {
+TExecFunc arrow_box_eq() { return TGenericExec<TPgDirectFunc<&box_eq>, true, true, TArgs_box_eq_Policy>({}); }
+struct TArgs_box_ge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_byteaGetBit() { return &GenericExec<TPgDirectFunc<&byteaGetBit>, true, true, TArgs_byteaGetBit_Policy>; }
-struct TArgs_byteaGetByte_Policy {
+TExecFunc arrow_box_ge() { return TGenericExec<TPgDirectFunc<&box_ge>, true, true, TArgs_box_ge_Policy>({}); }
+struct TArgs_box_gt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_byteaGetByte() { return &GenericExec<TPgDirectFunc<&byteaGetByte>, true, true, TArgs_byteaGetByte_Policy>; }
-struct TArgs_byteaSetBit_Policy {
+TExecFunc arrow_box_gt() { return TGenericExec<TPgDirectFunc<&box_gt>, true, true, TArgs_box_gt_Policy>({}); }
+struct TArgs_box_height_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_byteaSetBit() { return &GenericExec<TPgDirectFunc<&byteaSetBit>, true, false, TArgs_byteaSetBit_Policy>; }
-struct TArgs_byteaSetByte_Policy {
+TExecFunc arrow_box_height() { return TGenericExec<TPgDirectFunc<&box_height>, true, true, TArgs_box_height_Policy>({}); }
+struct TArgs_box_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_byteaSetByte() { return &GenericExec<TPgDirectFunc<&byteaSetByte>, true, false, TArgs_byteaSetByte_Policy>; }
-struct TArgs_bytea_bit_count_Policy {
+TExecFunc arrow_box_in() { return TGenericExec<TPgDirectFunc<&box_in>, true, false, TArgs_box_in_Policy>({}); }
+struct TArgs_box_intersect_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_bytea_bit_count() { return &GenericExec<TPgDirectFunc<&bytea_bit_count>, true, true, TArgs_bytea_bit_count_Policy>; }
-struct TArgs_bytea_sortsupport_Policy {
+TExecFunc arrow_box_intersect() { return TGenericExec<TPgDirectFunc<&box_intersect>, true, false, TArgs_box_intersect_Policy>({}); }
+struct TArgs_box_le_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_bytea_sortsupport() { return &GenericExec<TPgDirectFunc<&bytea_sortsupport>, true, true, TArgs_bytea_sortsupport_Policy>; }
-struct TArgs_bytea_string_agg_finalfn_Policy {
+TExecFunc arrow_box_le() { return TGenericExec<TPgDirectFunc<&box_le>, true, true, TArgs_box_le_Policy>({}); }
+struct TArgs_box_left_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_bytea_string_agg_finalfn() { return &GenericExec<TPgDirectFunc<&bytea_string_agg_finalfn>, false, false, TArgs_bytea_string_agg_finalfn_Policy>; }
-struct TArgs_bytea_string_agg_transfn_Policy {
+TExecFunc arrow_box_left() { return TGenericExec<TPgDirectFunc<&box_left>, true, true, TArgs_box_left_Policy>({}); }
+struct TArgs_box_lt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_bytea_string_agg_transfn() { return &GenericExec<TPgDirectFunc<&bytea_string_agg_transfn>, false, true, TArgs_bytea_string_agg_transfn_Policy>; }
-struct TArgs_bytea_substr_Policy {
+TExecFunc arrow_box_lt() { return TGenericExec<TPgDirectFunc<&box_lt>, true, true, TArgs_box_lt_Policy>({}); }
+struct TArgs_box_mul_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_bytea_substr() { return &GenericExec<TPgDirectFunc<&bytea_substr>, true, false, TArgs_bytea_substr_Policy>; }
-struct TArgs_bytea_substr_no_len_Policy {
+TExecFunc arrow_box_mul() { return TGenericExec<TPgDirectFunc<&box_mul>, true, false, TArgs_box_mul_Policy>({}); }
+struct TArgs_box_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_bytea_substr_no_len() { return &GenericExec<TPgDirectFunc<&bytea_substr_no_len>, true, false, TArgs_bytea_substr_no_len_Policy>; }
-struct TArgs_byteacat_Policy {
+TExecFunc arrow_box_out() { return TGenericExec<TPgDirectFunc<&box_out>, true, false, TArgs_box_out_Policy>({}); }
+struct TArgs_box_overabove_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_byteacat() { return &GenericExec<TPgDirectFunc<&byteacat>, true, false, TArgs_byteacat_Policy>; }
-struct TArgs_byteacmp_Policy {
+TExecFunc arrow_box_overabove() { return TGenericExec<TPgDirectFunc<&box_overabove>, true, true, TArgs_box_overabove_Policy>({}); }
+struct TArgs_box_overbelow_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_byteacmp() { return &GenericExec<TPgDirectFunc<&byteacmp>, true, true, TArgs_byteacmp_Policy>; }
-struct TArgs_byteaeq_Policy {
+TExecFunc arrow_box_overbelow() { return TGenericExec<TPgDirectFunc<&box_overbelow>, true, true, TArgs_box_overbelow_Policy>({}); }
+struct TArgs_box_overlap_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_byteaeq() { return &GenericExec<TPgDirectFunc<&byteaeq>, true, true, TArgs_byteaeq_Policy>; }
-struct TArgs_byteage_Policy {
+TExecFunc arrow_box_overlap() { return TGenericExec<TPgDirectFunc<&box_overlap>, true, true, TArgs_box_overlap_Policy>({}); }
+struct TArgs_box_overleft_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_byteage() { return &GenericExec<TPgDirectFunc<&byteage>, true, true, TArgs_byteage_Policy>; }
-struct TArgs_byteagt_Policy {
+TExecFunc arrow_box_overleft() { return TGenericExec<TPgDirectFunc<&box_overleft>, true, true, TArgs_box_overleft_Policy>({}); }
+struct TArgs_box_overright_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_byteagt() { return &GenericExec<TPgDirectFunc<&byteagt>, true, true, TArgs_byteagt_Policy>; }
-struct TArgs_byteain_Policy {
+TExecFunc arrow_box_overright() { return TGenericExec<TPgDirectFunc<&box_overright>, true, true, TArgs_box_overright_Policy>({}); }
+struct TArgs_box_poly_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_byteain() { return &GenericExec<TPgDirectFunc<&byteain>, true, false, TArgs_byteain_Policy>; }
-struct TArgs_byteale_Policy {
+TExecFunc arrow_box_poly() { return TGenericExec<TPgDirectFunc<&box_poly>, true, false, TArgs_box_poly_Policy>({}); }
+struct TArgs_box_recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_byteale() { return &GenericExec<TPgDirectFunc<&byteale>, true, true, TArgs_byteale_Policy>; }
-struct TArgs_bytealt_Policy {
+TExecFunc arrow_box_recv() { return TGenericExec<TPgDirectFunc<&box_recv>, true, false, TArgs_box_recv_Policy>({}); }
+struct TArgs_box_right_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_bytealt() { return &GenericExec<TPgDirectFunc<&bytealt>, true, true, TArgs_bytealt_Policy>; }
-struct TArgs_byteane_Policy {
+TExecFunc arrow_box_right() { return TGenericExec<TPgDirectFunc<&box_right>, true, true, TArgs_box_right_Policy>({}); }
+struct TArgs_box_same_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_byteane() { return &GenericExec<TPgDirectFunc<&byteane>, true, true, TArgs_byteane_Policy>; }
-struct TArgs_byteaoctetlen_Policy {
+TExecFunc arrow_box_same() { return TGenericExec<TPgDirectFunc<&box_same>, true, true, TArgs_box_same_Policy>({}); }
+struct TArgs_box_send_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_byteaoctetlen() { return &GenericExec<TPgDirectFunc<&byteaoctetlen>, true, true, TArgs_byteaoctetlen_Policy>; }
-struct TArgs_byteaout_Policy {
+TExecFunc arrow_box_send() { return TGenericExec<TPgDirectFunc<&box_send>, true, false, TArgs_box_send_Policy>({}); }
+struct TArgs_box_sub_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_box_sub() { return TGenericExec<TPgDirectFunc<&box_sub>, true, false, TArgs_box_sub_Policy>({}); }
+struct TArgs_box_width_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_byteaout() { return &GenericExec<TPgDirectFunc<&byteaout>, true, false, TArgs_byteaout_Policy>; }
-struct TArgs_byteaoverlay_Policy {
+TExecFunc arrow_box_width() { return TGenericExec<TPgDirectFunc<&box_width>, true, true, TArgs_box_width_Policy>({}); }
+struct TArgs_boxes_bound_box_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,false,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_byteaoverlay() { return &GenericExec<TPgDirectFunc<&byteaoverlay>, true, false, TArgs_byteaoverlay_Policy>; }
-struct TArgs_byteaoverlay_no_len_Policy {
+TExecFunc arrow_boxes_bound_box() { return TGenericExec<TPgDirectFunc<&boxes_bound_box>, true, false, TArgs_boxes_bound_box_Policy>({}); }
+struct TArgs_brin_bloom_add_value_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,true};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_byteaoverlay_no_len() { return &GenericExec<TPgDirectFunc<&byteaoverlay_no_len>, true, false, TArgs_byteaoverlay_no_len_Policy>; }
-struct TArgs_byteapos_Policy {
+TExecFunc arrow_brin_bloom_add_value() { return TGenericExec<TPgDirectFunc<&brin_bloom_add_value>, true, true, TArgs_brin_bloom_add_value_Policy>({}); }
+struct TArgs_brin_bloom_consistent_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_byteapos() { return &GenericExec<TPgDirectFunc<&byteapos>, true, true, TArgs_byteapos_Policy>; }
-struct TArgs_bytearecv_Policy {
+TExecFunc arrow_brin_bloom_consistent() { return TGenericExec<TPgDirectFunc<&brin_bloom_consistent>, true, true, TArgs_brin_bloom_consistent_Policy>({}); }
+struct TArgs_brin_bloom_opcinfo_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_bytearecv() { return &GenericExec<TPgDirectFunc<&bytearecv>, true, false, TArgs_bytearecv_Policy>; }
-struct TArgs_byteasend_Policy {
+TExecFunc arrow_brin_bloom_opcinfo() { return TGenericExec<TPgDirectFunc<&brin_bloom_opcinfo>, true, true, TArgs_brin_bloom_opcinfo_Policy>({}); }
+struct TArgs_brin_bloom_options_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_brin_bloom_options() { return TGenericExec<TPgDirectFunc<&brin_bloom_options>, false, true, TArgs_brin_bloom_options_Policy>({}); }
+struct TArgs_brin_bloom_summary_in_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_brin_bloom_summary_in() { return TGenericExec<TPgDirectFunc<&brin_bloom_summary_in>, true, false, TArgs_brin_bloom_summary_in_Policy>({}); }
+struct TArgs_brin_bloom_summary_out_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_brin_bloom_summary_out() { return TGenericExec<TPgDirectFunc<&brin_bloom_summary_out>, true, false, TArgs_brin_bloom_summary_out_Policy>({}); }
+struct TArgs_brin_bloom_summary_recv_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_brin_bloom_summary_recv() { return TGenericExec<TPgDirectFunc<&brin_bloom_summary_recv>, true, false, TArgs_brin_bloom_summary_recv_Policy>({}); }
+struct TArgs_brin_bloom_summary_send_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_byteasend() { return &GenericExec<TPgDirectFunc<&byteasend>, true, false, TArgs_byteasend_Policy>; }
+TExecFunc arrow_brin_bloom_summary_send() { return TGenericExec<TPgDirectFunc<&brin_bloom_summary_send>, true, false, TArgs_brin_bloom_summary_send_Policy>({}); }
+struct TArgs_brin_bloom_union_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
+};
+TExecFunc arrow_brin_bloom_union() { return TGenericExec<TPgDirectFunc<&brin_bloom_union>, true, true, TArgs_brin_bloom_union_Policy>({}); }
+struct TArgs_bttidcmp_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_bttidcmp() { return TGenericExec<TPgDirectFunc<&bttidcmp>, true, true, TArgs_bttidcmp_Policy>({}); }
 struct TArgs_cash_cmp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_cash_cmp() { return &GenericExec<TPgDirectFunc<&cash_cmp>, true, true, TArgs_cash_cmp_Policy>; }
+TExecFunc arrow_cash_cmp() { return TGenericExec<TPgDirectFunc<&cash_cmp>, true, true, TArgs_cash_cmp_Policy>({}); }
 struct TArgs_cash_div_cash_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_cash_div_cash() { return &GenericExec<TPgDirectFunc<&cash_div_cash>, true, true, TArgs_cash_div_cash_Policy>; }
+TExecFunc arrow_cash_div_cash() { return TGenericExec<TPgDirectFunc<&cash_div_cash>, true, true, TArgs_cash_div_cash_Policy>({}); }
 struct TArgs_cash_div_flt4_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_cash_div_flt4() { return &GenericExec<TPgDirectFunc<&cash_div_flt4>, true, true, TArgs_cash_div_flt4_Policy>; }
+TExecFunc arrow_cash_div_flt4() { return TGenericExec<TPgDirectFunc<&cash_div_flt4>, true, true, TArgs_cash_div_flt4_Policy>({}); }
 struct TArgs_cash_div_flt8_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_cash_div_flt8() { return &GenericExec<TPgDirectFunc<&cash_div_flt8>, true, true, TArgs_cash_div_flt8_Policy>; }
+TExecFunc arrow_cash_div_flt8() { return TGenericExec<TPgDirectFunc<&cash_div_flt8>, true, true, TArgs_cash_div_flt8_Policy>({}); }
 struct TArgs_cash_div_int2_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_cash_div_int2() { return &GenericExec<TPgDirectFunc<&cash_div_int2>, true, true, TArgs_cash_div_int2_Policy>; }
+TExecFunc arrow_cash_div_int2() { return TGenericExec<TPgDirectFunc<&cash_div_int2>, true, true, TArgs_cash_div_int2_Policy>({}); }
 struct TArgs_cash_div_int4_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_cash_div_int4() { return &GenericExec<TPgDirectFunc<&cash_div_int4>, true, true, TArgs_cash_div_int4_Policy>; }
+TExecFunc arrow_cash_div_int4() { return TGenericExec<TPgDirectFunc<&cash_div_int4>, true, true, TArgs_cash_div_int4_Policy>({}); }
 struct TArgs_cash_div_int8_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_cash_div_int8() { return &GenericExec<TPgDirectFunc<&cash_div_int8>, true, true, TArgs_cash_div_int8_Policy>; }
+TExecFunc arrow_cash_div_int8() { return TGenericExec<TPgDirectFunc<&cash_div_int8>, true, true, TArgs_cash_div_int8_Policy>({}); }
 struct TArgs_cash_eq_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_cash_eq() { return &GenericExec<TPgDirectFunc<&cash_eq>, true, true, TArgs_cash_eq_Policy>; }
+TExecFunc arrow_cash_eq() { return TGenericExec<TPgDirectFunc<&cash_eq>, true, true, TArgs_cash_eq_Policy>({}); }
 struct TArgs_cash_ge_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_cash_ge() { return &GenericExec<TPgDirectFunc<&cash_ge>, true, true, TArgs_cash_ge_Policy>; }
+TExecFunc arrow_cash_ge() { return TGenericExec<TPgDirectFunc<&cash_ge>, true, true, TArgs_cash_ge_Policy>({}); }
 struct TArgs_cash_gt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_cash_gt() { return &GenericExec<TPgDirectFunc<&cash_gt>, true, true, TArgs_cash_gt_Policy>; }
+TExecFunc arrow_cash_gt() { return TGenericExec<TPgDirectFunc<&cash_gt>, true, true, TArgs_cash_gt_Policy>({}); }
 struct TArgs_cash_in_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_cash_in() { return &GenericExec<TPgDirectFunc<&cash_in>, true, true, TArgs_cash_in_Policy>; }
+TExecFunc arrow_cash_in() { return TGenericExec<TPgDirectFunc<&cash_in>, true, true, TArgs_cash_in_Policy>({}); }
 struct TArgs_cash_le_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_cash_le() { return &GenericExec<TPgDirectFunc<&cash_le>, true, true, TArgs_cash_le_Policy>; }
+TExecFunc arrow_cash_le() { return TGenericExec<TPgDirectFunc<&cash_le>, true, true, TArgs_cash_le_Policy>({}); }
 struct TArgs_cash_lt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_cash_lt() { return &GenericExec<TPgDirectFunc<&cash_lt>, true, true, TArgs_cash_lt_Policy>; }
+TExecFunc arrow_cash_lt() { return TGenericExec<TPgDirectFunc<&cash_lt>, true, true, TArgs_cash_lt_Policy>({}); }
 struct TArgs_cash_mi_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_cash_mi() { return &GenericExec<TPgDirectFunc<&cash_mi>, true, true, TArgs_cash_mi_Policy>; }
+TExecFunc arrow_cash_mi() { return TGenericExec<TPgDirectFunc<&cash_mi>, true, true, TArgs_cash_mi_Policy>({}); }
 struct TArgs_cash_mul_flt4_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_cash_mul_flt4() { return &GenericExec<TPgDirectFunc<&cash_mul_flt4>, true, true, TArgs_cash_mul_flt4_Policy>; }
+TExecFunc arrow_cash_mul_flt4() { return TGenericExec<TPgDirectFunc<&cash_mul_flt4>, true, true, TArgs_cash_mul_flt4_Policy>({}); }
 struct TArgs_cash_mul_flt8_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_cash_mul_flt8() { return &GenericExec<TPgDirectFunc<&cash_mul_flt8>, true, true, TArgs_cash_mul_flt8_Policy>; }
+TExecFunc arrow_cash_mul_flt8() { return TGenericExec<TPgDirectFunc<&cash_mul_flt8>, true, true, TArgs_cash_mul_flt8_Policy>({}); }
 struct TArgs_cash_mul_int2_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_cash_mul_int2() { return &GenericExec<TPgDirectFunc<&cash_mul_int2>, true, true, TArgs_cash_mul_int2_Policy>; }
+TExecFunc arrow_cash_mul_int2() { return TGenericExec<TPgDirectFunc<&cash_mul_int2>, true, true, TArgs_cash_mul_int2_Policy>({}); }
 struct TArgs_cash_mul_int4_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_cash_mul_int4() { return &GenericExec<TPgDirectFunc<&cash_mul_int4>, true, true, TArgs_cash_mul_int4_Policy>; }
+TExecFunc arrow_cash_mul_int4() { return TGenericExec<TPgDirectFunc<&cash_mul_int4>, true, true, TArgs_cash_mul_int4_Policy>({}); }
 struct TArgs_cash_mul_int8_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_cash_mul_int8() { return &GenericExec<TPgDirectFunc<&cash_mul_int8>, true, true, TArgs_cash_mul_int8_Policy>; }
+TExecFunc arrow_cash_mul_int8() { return TGenericExec<TPgDirectFunc<&cash_mul_int8>, true, true, TArgs_cash_mul_int8_Policy>({}); }
 struct TArgs_cash_ne_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_cash_ne() { return &GenericExec<TPgDirectFunc<&cash_ne>, true, true, TArgs_cash_ne_Policy>; }
+TExecFunc arrow_cash_ne() { return TGenericExec<TPgDirectFunc<&cash_ne>, true, true, TArgs_cash_ne_Policy>({}); }
 struct TArgs_cash_numeric_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_cash_numeric() { return &GenericExec<TPgDirectFunc<&cash_numeric>, true, false, TArgs_cash_numeric_Policy>; }
+TExecFunc arrow_cash_numeric() { return TGenericExec<TPgDirectFunc<&cash_numeric>, true, false, TArgs_cash_numeric_Policy>({}); }
 struct TArgs_cash_out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_cash_out() { return &GenericExec<TPgDirectFunc<&cash_out>, true, false, TArgs_cash_out_Policy>; }
+TExecFunc arrow_cash_out() { return TGenericExec<TPgDirectFunc<&cash_out>, true, false, TArgs_cash_out_Policy>({}); }
 struct TArgs_cash_pl_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_cash_pl() { return &GenericExec<TPgDirectFunc<&cash_pl>, true, true, TArgs_cash_pl_Policy>; }
+TExecFunc arrow_cash_pl() { return TGenericExec<TPgDirectFunc<&cash_pl>, true, true, TArgs_cash_pl_Policy>({}); }
 struct TArgs_cash_recv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_cash_recv() { return &GenericExec<TPgDirectFunc<&cash_recv>, true, true, TArgs_cash_recv_Policy>; }
+TExecFunc arrow_cash_recv() { return TGenericExec<TPgDirectFunc<&cash_recv>, true, true, TArgs_cash_recv_Policy>({}); }
 struct TArgs_cash_send_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_cash_send() { return &GenericExec<TPgDirectFunc<&cash_send>, true, false, TArgs_cash_send_Policy>; }
+TExecFunc arrow_cash_send() { return TGenericExec<TPgDirectFunc<&cash_send>, true, false, TArgs_cash_send_Policy>({}); }
 struct TArgs_cash_words_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_cash_words() { return &GenericExec<TPgDirectFunc<&cash_words>, true, false, TArgs_cash_words_Policy>; }
+TExecFunc arrow_cash_words() { return TGenericExec<TPgDirectFunc<&cash_words>, true, false, TArgs_cash_words_Policy>({}); }
 struct TArgs_cashlarger_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_cashlarger() { return &GenericExec<TPgDirectFunc<&cashlarger>, true, true, TArgs_cashlarger_Policy>; }
+TExecFunc arrow_cashlarger() { return TGenericExec<TPgDirectFunc<&cashlarger>, true, true, TArgs_cashlarger_Policy>({}); }
 struct TArgs_cashsmaller_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_cashsmaller() { return &GenericExec<TPgDirectFunc<&cashsmaller>, true, true, TArgs_cashsmaller_Policy>; }
-struct TArgs_char_text_Policy {
+TExecFunc arrow_cashsmaller() { return TGenericExec<TPgDirectFunc<&cashsmaller>, true, true, TArgs_cashsmaller_Policy>({}); }
+struct TArgs_circle_above_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_char_text() { return &GenericExec<TPgDirectFunc<&char_text>, true, false, TArgs_char_text_Policy>; }
-struct TArgs_chareq_Policy {
+TExecFunc arrow_circle_above() { return TGenericExec<TPgDirectFunc<&circle_above>, true, true, TArgs_circle_above_Policy>({}); }
+struct TArgs_circle_add_pt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_chareq() { return &GenericExec<TPgDirectFunc<&chareq>, true, true, TArgs_chareq_Policy>; }
-struct TArgs_charge_Policy {
+TExecFunc arrow_circle_add_pt() { return TGenericExec<TPgDirectFunc<&circle_add_pt>, true, false, TArgs_circle_add_pt_Policy>({}); }
+struct TArgs_circle_area_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_charge() { return &GenericExec<TPgDirectFunc<&charge>, true, true, TArgs_charge_Policy>; }
-struct TArgs_chargt_Policy {
+TExecFunc arrow_circle_area() { return TGenericExec<TPgDirectFunc<&circle_area>, true, true, TArgs_circle_area_Policy>({}); }
+struct TArgs_circle_below_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_chargt() { return &GenericExec<TPgDirectFunc<&chargt>, true, true, TArgs_chargt_Policy>; }
-struct TArgs_charin_Policy {
+TExecFunc arrow_circle_below() { return TGenericExec<TPgDirectFunc<&circle_below>, true, true, TArgs_circle_below_Policy>({}); }
+struct TArgs_circle_box_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_charin() { return &GenericExec<TPgDirectFunc<&charin>, true, true, TArgs_charin_Policy>; }
-struct TArgs_charle_Policy {
+TExecFunc arrow_circle_box() { return TGenericExec<TPgDirectFunc<&circle_box>, true, false, TArgs_circle_box_Policy>({}); }
+struct TArgs_circle_center_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_charle() { return &GenericExec<TPgDirectFunc<&charle>, true, true, TArgs_charle_Policy>; }
-struct TArgs_charlt_Policy {
+TExecFunc arrow_circle_center() { return TGenericExec<TPgDirectFunc<&circle_center>, true, false, TArgs_circle_center_Policy>({}); }
+struct TArgs_circle_contain_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_charlt() { return &GenericExec<TPgDirectFunc<&charlt>, true, true, TArgs_charlt_Policy>; }
-struct TArgs_charne_Policy {
+TExecFunc arrow_circle_contain() { return TGenericExec<TPgDirectFunc<&circle_contain>, true, true, TArgs_circle_contain_Policy>({}); }
+struct TArgs_circle_contain_pt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_charne() { return &GenericExec<TPgDirectFunc<&charne>, true, true, TArgs_charne_Policy>; }
-struct TArgs_charout_Policy {
+TExecFunc arrow_circle_contain_pt() { return TGenericExec<TPgDirectFunc<&circle_contain_pt>, true, true, TArgs_circle_contain_pt_Policy>({}); }
+struct TArgs_circle_contained_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_charout() { return &GenericExec<TPgDirectFunc<&charout>, true, false, TArgs_charout_Policy>; }
-struct TArgs_charrecv_Policy {
+TExecFunc arrow_circle_contained() { return TGenericExec<TPgDirectFunc<&circle_contained>, true, true, TArgs_circle_contained_Policy>({}); }
+struct TArgs_circle_diameter_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_charrecv() { return &GenericExec<TPgDirectFunc<&charrecv>, true, true, TArgs_charrecv_Policy>; }
-struct TArgs_charsend_Policy {
+TExecFunc arrow_circle_diameter() { return TGenericExec<TPgDirectFunc<&circle_diameter>, true, true, TArgs_circle_diameter_Policy>({}); }
+struct TArgs_circle_distance_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_charsend() { return &GenericExec<TPgDirectFunc<&charsend>, true, false, TArgs_charsend_Policy>; }
-struct TArgs_chartoi4_Policy {
+TExecFunc arrow_circle_distance() { return TGenericExec<TPgDirectFunc<&circle_distance>, true, true, TArgs_circle_distance_Policy>({}); }
+struct TArgs_circle_div_pt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_chartoi4() { return &GenericExec<TPgDirectFunc<&chartoi4>, true, true, TArgs_chartoi4_Policy>; }
-struct TArgs_cursor_to_xml_Policy {
+TExecFunc arrow_circle_div_pt() { return TGenericExec<TPgDirectFunc<&circle_div_pt>, true, false, TArgs_circle_div_pt_Policy>({}); }
+struct TArgs_circle_eq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {false,true,true,true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_cursor_to_xml() { return &GenericExec<TPgDirectFunc<&cursor_to_xml>, true, false, TArgs_cursor_to_xml_Policy>; }
-struct TArgs_cursor_to_xmlschema_Policy {
+TExecFunc arrow_circle_eq() { return TGenericExec<TPgDirectFunc<&circle_eq>, true, true, TArgs_circle_eq_Policy>({}); }
+struct TArgs_circle_ge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,true,true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_cursor_to_xmlschema() { return &GenericExec<TPgDirectFunc<&cursor_to_xmlschema>, true, false, TArgs_cursor_to_xmlschema_Policy>; }
-struct TArgs_dacos_Policy {
+TExecFunc arrow_circle_ge() { return TGenericExec<TPgDirectFunc<&circle_ge>, true, true, TArgs_circle_ge_Policy>({}); }
+struct TArgs_circle_gt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_dacos() { return &GenericExec<TPgDirectFunc<&dacos>, true, true, TArgs_dacos_Policy>; }
-struct TArgs_dacosd_Policy {
+TExecFunc arrow_circle_gt() { return TGenericExec<TPgDirectFunc<&circle_gt>, true, true, TArgs_circle_gt_Policy>({}); }
+struct TArgs_circle_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_dacosd() { return &GenericExec<TPgDirectFunc<&dacosd>, true, true, TArgs_dacosd_Policy>; }
-struct TArgs_dacosh_Policy {
+TExecFunc arrow_circle_in() { return TGenericExec<TPgDirectFunc<&circle_in>, true, false, TArgs_circle_in_Policy>({}); }
+struct TArgs_circle_le_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_dacosh() { return &GenericExec<TPgDirectFunc<&dacosh>, true, true, TArgs_dacosh_Policy>; }
-struct TArgs_dasin_Policy {
+TExecFunc arrow_circle_le() { return TGenericExec<TPgDirectFunc<&circle_le>, true, true, TArgs_circle_le_Policy>({}); }
+struct TArgs_circle_left_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_dasin() { return &GenericExec<TPgDirectFunc<&dasin>, true, true, TArgs_dasin_Policy>; }
-struct TArgs_dasind_Policy {
+TExecFunc arrow_circle_left() { return TGenericExec<TPgDirectFunc<&circle_left>, true, true, TArgs_circle_left_Policy>({}); }
+struct TArgs_circle_lt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_dasind() { return &GenericExec<TPgDirectFunc<&dasind>, true, true, TArgs_dasind_Policy>; }
-struct TArgs_dasinh_Policy {
+TExecFunc arrow_circle_lt() { return TGenericExec<TPgDirectFunc<&circle_lt>, true, true, TArgs_circle_lt_Policy>({}); }
+struct TArgs_circle_mul_pt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_dasinh() { return &GenericExec<TPgDirectFunc<&dasinh>, true, true, TArgs_dasinh_Policy>; }
-struct TArgs_database_to_xml_Policy {
+TExecFunc arrow_circle_mul_pt() { return TGenericExec<TPgDirectFunc<&circle_mul_pt>, true, false, TArgs_circle_mul_pt_Policy>({}); }
+struct TArgs_circle_ne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_database_to_xml() { return &GenericExec<TPgDirectFunc<&database_to_xml>, true, false, TArgs_database_to_xml_Policy>; }
-struct TArgs_database_to_xml_and_xmlschema_Policy {
+TExecFunc arrow_circle_ne() { return TGenericExec<TPgDirectFunc<&circle_ne>, true, true, TArgs_circle_ne_Policy>({}); }
+struct TArgs_circle_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_database_to_xml_and_xmlschema() { return &GenericExec<TPgDirectFunc<&database_to_xml_and_xmlschema>, true, false, TArgs_database_to_xml_and_xmlschema_Policy>; }
-struct TArgs_database_to_xmlschema_Policy {
+TExecFunc arrow_circle_out() { return TGenericExec<TPgDirectFunc<&circle_out>, true, false, TArgs_circle_out_Policy>({}); }
+struct TArgs_circle_overabove_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_database_to_xmlschema() { return &GenericExec<TPgDirectFunc<&database_to_xmlschema>, true, false, TArgs_database_to_xmlschema_Policy>; }
-struct TArgs_datan_Policy {
+TExecFunc arrow_circle_overabove() { return TGenericExec<TPgDirectFunc<&circle_overabove>, true, true, TArgs_circle_overabove_Policy>({}); }
+struct TArgs_circle_overbelow_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_datan() { return &GenericExec<TPgDirectFunc<&datan>, true, true, TArgs_datan_Policy>; }
-struct TArgs_datan2_Policy {
+TExecFunc arrow_circle_overbelow() { return TGenericExec<TPgDirectFunc<&circle_overbelow>, true, true, TArgs_circle_overbelow_Policy>({}); }
+struct TArgs_circle_overlap_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_datan2() { return &GenericExec<TPgDirectFunc<&datan2>, true, true, TArgs_datan2_Policy>; }
-struct TArgs_datan2d_Policy {
+TExecFunc arrow_circle_overlap() { return TGenericExec<TPgDirectFunc<&circle_overlap>, true, true, TArgs_circle_overlap_Policy>({}); }
+struct TArgs_circle_overleft_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_datan2d() { return &GenericExec<TPgDirectFunc<&datan2d>, true, true, TArgs_datan2d_Policy>; }
-struct TArgs_datand_Policy {
+TExecFunc arrow_circle_overleft() { return TGenericExec<TPgDirectFunc<&circle_overleft>, true, true, TArgs_circle_overleft_Policy>({}); }
+struct TArgs_circle_overright_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_datand() { return &GenericExec<TPgDirectFunc<&datand>, true, true, TArgs_datand_Policy>; }
-struct TArgs_datanh_Policy {
+TExecFunc arrow_circle_overright() { return TGenericExec<TPgDirectFunc<&circle_overright>, true, true, TArgs_circle_overright_Policy>({}); }
+struct TArgs_circle_poly_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_datanh() { return &GenericExec<TPgDirectFunc<&datanh>, true, true, TArgs_datanh_Policy>; }
-struct TArgs_dcbrt_Policy {
+TExecFunc arrow_circle_poly() { return TGenericExec<TPgDirectFunc<&circle_poly>, true, false, TArgs_circle_poly_Policy>({}); }
+struct TArgs_circle_radius_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_dcbrt() { return &GenericExec<TPgDirectFunc<&dcbrt>, true, true, TArgs_dcbrt_Policy>; }
-struct TArgs_dceil_Policy {
+TExecFunc arrow_circle_radius() { return TGenericExec<TPgDirectFunc<&circle_radius>, true, true, TArgs_circle_radius_Policy>({}); }
+struct TArgs_circle_recv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_dceil() { return &GenericExec<TPgDirectFunc<&dceil>, true, true, TArgs_dceil_Policy>; }
-struct TArgs_dcos_Policy {
+TExecFunc arrow_circle_recv() { return TGenericExec<TPgDirectFunc<&circle_recv>, true, false, TArgs_circle_recv_Policy>({}); }
+struct TArgs_circle_right_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_dcos() { return &GenericExec<TPgDirectFunc<&dcos>, true, true, TArgs_dcos_Policy>; }
-struct TArgs_dcosd_Policy {
+TExecFunc arrow_circle_right() { return TGenericExec<TPgDirectFunc<&circle_right>, true, true, TArgs_circle_right_Policy>({}); }
+struct TArgs_circle_same_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_dcosd() { return &GenericExec<TPgDirectFunc<&dcosd>, true, true, TArgs_dcosd_Policy>; }
-struct TArgs_dcosh_Policy {
+TExecFunc arrow_circle_same() { return TGenericExec<TPgDirectFunc<&circle_same>, true, true, TArgs_circle_same_Policy>({}); }
+struct TArgs_circle_send_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_dcosh() { return &GenericExec<TPgDirectFunc<&dcosh>, true, true, TArgs_dcosh_Policy>; }
-struct TArgs_dcot_Policy {
+TExecFunc arrow_circle_send() { return TGenericExec<TPgDirectFunc<&circle_send>, true, false, TArgs_circle_send_Policy>({}); }
+struct TArgs_circle_sub_pt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_dcot() { return &GenericExec<TPgDirectFunc<&dcot>, true, true, TArgs_dcot_Policy>; }
-struct TArgs_dcotd_Policy {
+TExecFunc arrow_circle_sub_pt() { return TGenericExec<TPgDirectFunc<&circle_sub_pt>, true, false, TArgs_circle_sub_pt_Policy>({}); }
+struct TArgs_clock_timestamp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_dcotd() { return &GenericExec<TPgDirectFunc<&dcotd>, true, true, TArgs_dcotd_Policy>; }
-struct TArgs_degrees_Policy {
+TExecFunc arrow_clock_timestamp() { return TGenericExec<TPgDirectFunc<&clock_timestamp>, true, true, TArgs_clock_timestamp_Policy>({}); }
+struct TArgs_close_lb_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_degrees() { return &GenericExec<TPgDirectFunc<&degrees>, true, true, TArgs_degrees_Policy>; }
-struct TArgs_dexp_Policy {
+TExecFunc arrow_close_lb() { return TGenericExec<TPgDirectFunc<&close_lb>, true, false, TArgs_close_lb_Policy>({}); }
+struct TArgs_close_ls_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_dexp() { return &GenericExec<TPgDirectFunc<&dexp>, true, true, TArgs_dexp_Policy>; }
-struct TArgs_dfloor_Policy {
+TExecFunc arrow_close_ls() { return TGenericExec<TPgDirectFunc<&close_ls>, true, false, TArgs_close_ls_Policy>({}); }
+struct TArgs_close_lseg_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_dfloor() { return &GenericExec<TPgDirectFunc<&dfloor>, true, true, TArgs_dfloor_Policy>; }
-struct TArgs_dlog1_Policy {
+TExecFunc arrow_close_lseg() { return TGenericExec<TPgDirectFunc<&close_lseg>, true, false, TArgs_close_lseg_Policy>({}); }
+struct TArgs_close_pb_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_dlog1() { return &GenericExec<TPgDirectFunc<&dlog1>, true, true, TArgs_dlog1_Policy>; }
-struct TArgs_dlog10_Policy {
+TExecFunc arrow_close_pb() { return TGenericExec<TPgDirectFunc<&close_pb>, true, false, TArgs_close_pb_Policy>({}); }
+struct TArgs_close_pl_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_dlog10() { return &GenericExec<TPgDirectFunc<&dlog10>, true, true, TArgs_dlog10_Policy>; }
-struct TArgs_domain_in_Policy {
+TExecFunc arrow_close_pl() { return TGenericExec<TPgDirectFunc<&close_pl>, true, false, TArgs_close_pl_Policy>({}); }
+struct TArgs_close_ps_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_domain_in() { return &GenericExec<TPgDirectFunc<&domain_in>, false, true, TArgs_domain_in_Policy>; }
-struct TArgs_domain_recv_Policy {
+TExecFunc arrow_close_ps() { return TGenericExec<TPgDirectFunc<&close_ps>, true, false, TArgs_close_ps_Policy>({}); }
+struct TArgs_close_sb_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_domain_recv() { return &GenericExec<TPgDirectFunc<&domain_recv>, false, true, TArgs_domain_recv_Policy>; }
-struct TArgs_dpi_Policy {
+TExecFunc arrow_close_sb() { return TGenericExec<TPgDirectFunc<&close_sb>, true, false, TArgs_close_sb_Policy>({}); }
+struct TArgs_close_sl_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_dpi() { return &GenericExec<TPgDirectFunc<&dpi>, true, true, TArgs_dpi_Policy>; }
-struct TArgs_dpow_Policy {
+TExecFunc arrow_close_sl() { return TGenericExec<TPgDirectFunc<&close_sl>, true, false, TArgs_close_sl_Policy>({}); }
+struct TArgs_construct_point_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_dpow() { return &GenericExec<TPgDirectFunc<&dpow>, true, true, TArgs_dpow_Policy>; }
-struct TArgs_drandom_Policy {
+TExecFunc arrow_construct_point() { return TGenericExec<TPgDirectFunc<&construct_point>, true, false, TArgs_construct_point_Policy>({}); }
+struct TArgs_contjoinsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
 };
-TExecFunc arrow_drandom() { return &GenericExec<TPgDirectFunc<&drandom>, true, true, TArgs_drandom_Policy>; }
-struct TArgs_dround_Policy {
+TExecFunc arrow_contjoinsel() { return TGenericExec<TPgDirectFunc<&contjoinsel>, true, true, TArgs_contjoinsel_Policy>({}); }
+struct TArgs_contsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_dround() { return &GenericExec<TPgDirectFunc<&dround>, true, true, TArgs_dround_Policy>; }
-struct TArgs_dsign_Policy {
+TExecFunc arrow_contsel() { return TGenericExec<TPgDirectFunc<&contsel>, true, true, TArgs_contsel_Policy>({}); }
+struct TArgs_cr_circle_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_dsign() { return &GenericExec<TPgDirectFunc<&dsign>, true, true, TArgs_dsign_Policy>; }
-struct TArgs_dsin_Policy {
+TExecFunc arrow_cr_circle() { return TGenericExec<TPgDirectFunc<&cr_circle>, true, false, TArgs_cr_circle_Policy>({}); }
+struct TArgs_current_database_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_dsin() { return &GenericExec<TPgDirectFunc<&dsin>, true, true, TArgs_dsin_Policy>; }
-struct TArgs_dsind_Policy {
+TExecFunc arrow_current_database() { return TGenericExec<TPgDirectFunc<&current_database>, true, false, TArgs_current_database_Policy>({}); }
+struct TArgs_current_query_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_dsind() { return &GenericExec<TPgDirectFunc<&dsind>, true, true, TArgs_dsind_Policy>; }
-struct TArgs_dsinh_Policy {
+TExecFunc arrow_current_query() { return TGenericExec<TPgDirectFunc<&current_query>, false, false, TArgs_current_query_Policy>({}); }
+struct TArgs_currtid_byrelname_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_dsinh() { return &GenericExec<TPgDirectFunc<&dsinh>, true, true, TArgs_dsinh_Policy>; }
-struct TArgs_dsqrt_Policy {
+TExecFunc arrow_currtid_byrelname() { return TGenericExec<TPgDirectFunc<&currtid_byrelname>, true, false, TArgs_currtid_byrelname_Policy>({}); }
+struct TArgs_dist_bl_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_dsqrt() { return &GenericExec<TPgDirectFunc<&dsqrt>, true, true, TArgs_dsqrt_Policy>; }
-struct TArgs_dtan_Policy {
+TExecFunc arrow_dist_bl() { return TGenericExec<TPgDirectFunc<&dist_bl>, true, true, TArgs_dist_bl_Policy>({}); }
+struct TArgs_dist_bp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_dtan() { return &GenericExec<TPgDirectFunc<&dtan>, true, true, TArgs_dtan_Policy>; }
-struct TArgs_dtand_Policy {
+TExecFunc arrow_dist_bp() { return TGenericExec<TPgDirectFunc<&dist_bp>, true, true, TArgs_dist_bp_Policy>({}); }
+struct TArgs_dist_bs_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_dtand() { return &GenericExec<TPgDirectFunc<&dtand>, true, true, TArgs_dtand_Policy>; }
-struct TArgs_dtanh_Policy {
+TExecFunc arrow_dist_bs() { return TGenericExec<TPgDirectFunc<&dist_bs>, true, true, TArgs_dist_bs_Policy>({}); }
+struct TArgs_dist_cpoint_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_dtanh() { return &GenericExec<TPgDirectFunc<&dtanh>, true, true, TArgs_dtanh_Policy>; }
-struct TArgs_dtof_Policy {
+TExecFunc arrow_dist_cpoint() { return TGenericExec<TPgDirectFunc<&dist_cpoint>, true, true, TArgs_dist_cpoint_Policy>({}); }
+struct TArgs_dist_cpoly_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_dtof() { return &GenericExec<TPgDirectFunc<&dtof>, true, true, TArgs_dtof_Policy>; }
-struct TArgs_dtoi2_Policy {
+TExecFunc arrow_dist_cpoly() { return TGenericExec<TPgDirectFunc<&dist_cpoly>, true, true, TArgs_dist_cpoly_Policy>({}); }
+struct TArgs_dist_lb_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_dtoi2() { return &GenericExec<TPgDirectFunc<&dtoi2>, true, true, TArgs_dtoi2_Policy>; }
-struct TArgs_dtoi4_Policy {
+TExecFunc arrow_dist_lb() { return TGenericExec<TPgDirectFunc<&dist_lb>, true, true, TArgs_dist_lb_Policy>({}); }
+struct TArgs_dist_lp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_dtoi4() { return &GenericExec<TPgDirectFunc<&dtoi4>, true, true, TArgs_dtoi4_Policy>; }
-struct TArgs_dtrunc_Policy {
+TExecFunc arrow_dist_lp() { return TGenericExec<TPgDirectFunc<&dist_lp>, true, true, TArgs_dist_lp_Policy>({}); }
+struct TArgs_dist_ls_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_dtrunc() { return &GenericExec<TPgDirectFunc<&dtrunc>, true, true, TArgs_dtrunc_Policy>; }
-struct TArgs_elem_contained_by_multirange_Policy {
+TExecFunc arrow_dist_ls() { return TGenericExec<TPgDirectFunc<&dist_ls>, true, true, TArgs_dist_ls_Policy>({}); }
+struct TArgs_dist_pathp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_elem_contained_by_multirange() { return &GenericExec<TPgDirectFunc<&elem_contained_by_multirange>, true, true, TArgs_elem_contained_by_multirange_Policy>; }
-struct TArgs_float48div_Policy {
+TExecFunc arrow_dist_pathp() { return TGenericExec<TPgDirectFunc<&dist_pathp>, true, true, TArgs_dist_pathp_Policy>({}); }
+struct TArgs_dist_pb_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_float48div() { return &GenericExec<TPgDirectFunc<&float48div>, true, true, TArgs_float48div_Policy>; }
-struct TArgs_float48eq_Policy {
+TExecFunc arrow_dist_pb() { return TGenericExec<TPgDirectFunc<&dist_pb>, true, true, TArgs_dist_pb_Policy>({}); }
+struct TArgs_dist_pc_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_float48eq() { return &GenericExec<TPgDirectFunc<&float48eq>, true, true, TArgs_float48eq_Policy>; }
-struct TArgs_float48ge_Policy {
+TExecFunc arrow_dist_pc() { return TGenericExec<TPgDirectFunc<&dist_pc>, true, true, TArgs_dist_pc_Policy>({}); }
+struct TArgs_dist_pl_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_float48ge() { return &GenericExec<TPgDirectFunc<&float48ge>, true, true, TArgs_float48ge_Policy>; }
-struct TArgs_float48gt_Policy {
+TExecFunc arrow_dist_pl() { return TGenericExec<TPgDirectFunc<&dist_pl>, true, true, TArgs_dist_pl_Policy>({}); }
+struct TArgs_dist_polyc_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_float48gt() { return &GenericExec<TPgDirectFunc<&float48gt>, true, true, TArgs_float48gt_Policy>; }
-struct TArgs_float48le_Policy {
+TExecFunc arrow_dist_polyc() { return TGenericExec<TPgDirectFunc<&dist_polyc>, true, true, TArgs_dist_polyc_Policy>({}); }
+struct TArgs_dist_polyp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_float48le() { return &GenericExec<TPgDirectFunc<&float48le>, true, true, TArgs_float48le_Policy>; }
-struct TArgs_float48lt_Policy {
+TExecFunc arrow_dist_polyp() { return TGenericExec<TPgDirectFunc<&dist_polyp>, true, true, TArgs_dist_polyp_Policy>({}); }
+struct TArgs_dist_ppath_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_float48lt() { return &GenericExec<TPgDirectFunc<&float48lt>, true, true, TArgs_float48lt_Policy>; }
-struct TArgs_float48mi_Policy {
+TExecFunc arrow_dist_ppath() { return TGenericExec<TPgDirectFunc<&dist_ppath>, true, true, TArgs_dist_ppath_Policy>({}); }
+struct TArgs_dist_ppoly_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_float48mi() { return &GenericExec<TPgDirectFunc<&float48mi>, true, true, TArgs_float48mi_Policy>; }
-struct TArgs_float48mul_Policy {
+TExecFunc arrow_dist_ppoly() { return TGenericExec<TPgDirectFunc<&dist_ppoly>, true, true, TArgs_dist_ppoly_Policy>({}); }
+struct TArgs_dist_ps_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_float48mul() { return &GenericExec<TPgDirectFunc<&float48mul>, true, true, TArgs_float48mul_Policy>; }
-struct TArgs_float48ne_Policy {
+TExecFunc arrow_dist_ps() { return TGenericExec<TPgDirectFunc<&dist_ps>, true, true, TArgs_dist_ps_Policy>({}); }
+struct TArgs_dist_sb_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_float48ne() { return &GenericExec<TPgDirectFunc<&float48ne>, true, true, TArgs_float48ne_Policy>; }
-struct TArgs_float48pl_Policy {
+TExecFunc arrow_dist_sb() { return TGenericExec<TPgDirectFunc<&dist_sb>, true, true, TArgs_dist_sb_Policy>({}); }
+struct TArgs_dist_sl_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_float48pl() { return &GenericExec<TPgDirectFunc<&float48pl>, true, true, TArgs_float48pl_Policy>; }
-struct TArgs_float4_accum_Policy {
+TExecFunc arrow_dist_sl() { return TGenericExec<TPgDirectFunc<&dist_sl>, true, true, TArgs_dist_sl_Policy>({}); }
+struct TArgs_dist_sp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_float4_accum() { return &GenericExec<TPgDirectFunc<&float4_accum>, true, false, TArgs_float4_accum_Policy>; }
-struct TArgs_float4abs_Policy {
+TExecFunc arrow_dist_sp() { return TGenericExec<TPgDirectFunc<&dist_sp>, true, true, TArgs_dist_sp_Policy>({}); }
+struct TArgs_extract_interval_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_float4abs() { return &GenericExec<TPgDirectFunc<&float4abs>, true, true, TArgs_float4abs_Policy>; }
-struct TArgs_float4div_Policy {
+TExecFunc arrow_extract_interval() { return TGenericExec<TPgDirectFunc<&extract_interval>, true, false, TArgs_extract_interval_Policy>({}); }
+struct TArgs_extract_timestamp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_float4div() { return &GenericExec<TPgDirectFunc<&float4div>, true, true, TArgs_float4div_Policy>; }
-struct TArgs_float4eq_Policy {
+TExecFunc arrow_extract_timestamp() { return TGenericExec<TPgDirectFunc<&extract_timestamp>, true, false, TArgs_extract_timestamp_Policy>({}); }
+struct TArgs_extract_timestamptz_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_float4eq() { return &GenericExec<TPgDirectFunc<&float4eq>, true, true, TArgs_float4eq_Policy>; }
-struct TArgs_float4ge_Policy {
+TExecFunc arrow_extract_timestamptz() { return TGenericExec<TPgDirectFunc<&extract_timestamptz>, true, false, TArgs_extract_timestamptz_Policy>({}); }
+struct TArgs_float4_numeric_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_float4ge() { return &GenericExec<TPgDirectFunc<&float4ge>, true, true, TArgs_float4ge_Policy>; }
-struct TArgs_float4gt_Policy {
+TExecFunc arrow_float4_numeric() { return TGenericExec<TPgDirectFunc<&float4_numeric>, true, false, TArgs_float4_numeric_Policy>({}); }
+struct TArgs_float4_to_char_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_float4gt() { return &GenericExec<TPgDirectFunc<&float4gt>, true, true, TArgs_float4gt_Policy>; }
-struct TArgs_float4in_Policy {
+TExecFunc arrow_float4_to_char() { return TGenericExec<TPgDirectFunc<&float4_to_char>, true, false, TArgs_float4_to_char_Policy>({}); }
+struct TArgs_float8_numeric_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_float4in() { return &GenericExec<TPgDirectFunc<&float4in>, true, true, TArgs_float4in_Policy>; }
-struct TArgs_float4larger_Policy {
+TExecFunc arrow_float8_numeric() { return TGenericExec<TPgDirectFunc<&float8_numeric>, true, false, TArgs_float8_numeric_Policy>({}); }
+struct TArgs_float8_timestamptz_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_float4larger() { return &GenericExec<TPgDirectFunc<&float4larger>, true, true, TArgs_float4larger_Policy>; }
-struct TArgs_float4le_Policy {
+TExecFunc arrow_float8_timestamptz() { return TGenericExec<TPgDirectFunc<&float8_timestamptz>, true, true, TArgs_float8_timestamptz_Policy>({}); }
+struct TArgs_float8_to_char_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_float4le() { return &GenericExec<TPgDirectFunc<&float4le>, true, true, TArgs_float4le_Policy>; }
-struct TArgs_float4lt_Policy {
+TExecFunc arrow_float8_to_char() { return TGenericExec<TPgDirectFunc<&float8_to_char>, true, false, TArgs_float8_to_char_Policy>({}); }
+struct TArgs_flt4_mul_cash_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_float4lt() { return &GenericExec<TPgDirectFunc<&float4lt>, true, true, TArgs_float4lt_Policy>; }
-struct TArgs_float4mi_Policy {
+TExecFunc arrow_flt4_mul_cash() { return TGenericExec<TPgDirectFunc<&flt4_mul_cash>, true, true, TArgs_flt4_mul_cash_Policy>({}); }
+struct TArgs_flt8_mul_cash_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_float4mi() { return &GenericExec<TPgDirectFunc<&float4mi>, true, true, TArgs_float4mi_Policy>; }
-struct TArgs_float4mul_Policy {
+TExecFunc arrow_flt8_mul_cash() { return TGenericExec<TPgDirectFunc<&flt8_mul_cash>, true, true, TArgs_flt8_mul_cash_Policy>({}); }
+struct TArgs_ginarrayconsistent_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 8> IsFixedArg = {true,true,false,true,true,true,true,true};
 };
-TExecFunc arrow_float4mul() { return &GenericExec<TPgDirectFunc<&float4mul>, true, true, TArgs_float4mul_Policy>; }
-struct TArgs_float4ne_Policy {
+TExecFunc arrow_ginarrayconsistent() { return TGenericExec<TPgDirectFunc<&ginarrayconsistent>, true, true, TArgs_ginarrayconsistent_Policy>({}); }
+struct TArgs_ginarrayextract_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_float4ne() { return &GenericExec<TPgDirectFunc<&float4ne>, true, true, TArgs_float4ne_Policy>; }
-struct TArgs_float4out_Policy {
+TExecFunc arrow_ginarrayextract() { return TGenericExec<TPgDirectFunc<&ginarrayextract>, true, true, TArgs_ginarrayextract_Policy>({}); }
+struct TArgs_ginarrayextract_2args_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_float4out() { return &GenericExec<TPgDirectFunc<&float4out>, true, false, TArgs_float4out_Policy>; }
-struct TArgs_float4pl_Policy {
+TExecFunc arrow_ginarrayextract_2args() { return TGenericExec<TPgDirectFunc<&ginarrayextract_2args>, true, true, TArgs_ginarrayextract_2args_Policy>({}); }
+struct TArgs_ginarraytriconsistent_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 7> IsFixedArg = {true,true,false,true,true,true,true};
 };
-TExecFunc arrow_float4pl() { return &GenericExec<TPgDirectFunc<&float4pl>, true, true, TArgs_float4pl_Policy>; }
-struct TArgs_float4recv_Policy {
+TExecFunc arrow_ginarraytriconsistent() { return TGenericExec<TPgDirectFunc<&ginarraytriconsistent>, true, true, TArgs_ginarraytriconsistent_Policy>({}); }
+struct TArgs_ginqueryarrayextract_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 7> IsFixedArg = {false,true,true,true,true,true,true};
 };
-TExecFunc arrow_float4recv() { return &GenericExec<TPgDirectFunc<&float4recv>, true, true, TArgs_float4recv_Policy>; }
-struct TArgs_float4send_Policy {
+TExecFunc arrow_ginqueryarrayextract() { return TGenericExec<TPgDirectFunc<&ginqueryarrayextract>, true, true, TArgs_ginqueryarrayextract_Policy>({}); }
+struct TArgs_hash_numeric_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_float4send() { return &GenericExec<TPgDirectFunc<&float4send>, true, false, TArgs_float4send_Policy>; }
-struct TArgs_float4smaller_Policy {
+TExecFunc arrow_hash_numeric() { return TGenericExec<TPgDirectFunc<&hash_numeric>, true, true, TArgs_hash_numeric_Policy>({}); }
+struct TArgs_hash_numeric_extended_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_float4smaller() { return &GenericExec<TPgDirectFunc<&float4smaller>, true, true, TArgs_float4smaller_Policy>; }
-struct TArgs_float4um_Policy {
+TExecFunc arrow_hash_numeric_extended() { return TGenericExec<TPgDirectFunc<&hash_numeric_extended>, true, true, TArgs_hash_numeric_extended_Policy>({}); }
+struct TArgs_hashtid_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_float4um() { return &GenericExec<TPgDirectFunc<&float4um>, true, true, TArgs_float4um_Policy>; }
-struct TArgs_float4up_Policy {
+TExecFunc arrow_hashtid() { return TGenericExec<TPgDirectFunc<&hashtid>, true, true, TArgs_hashtid_Policy>({}); }
+struct TArgs_hashtidextended_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_float4up() { return &GenericExec<TPgDirectFunc<&float4up>, true, true, TArgs_float4up_Policy>; }
-struct TArgs_float84div_Policy {
+TExecFunc arrow_hashtidextended() { return TGenericExec<TPgDirectFunc<&hashtidextended>, true, true, TArgs_hashtidextended_Policy>({}); }
+struct TArgs_iclikejoinsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
 };
-TExecFunc arrow_float84div() { return &GenericExec<TPgDirectFunc<&float84div>, true, true, TArgs_float84div_Policy>; }
-struct TArgs_float84eq_Policy {
+TExecFunc arrow_iclikejoinsel() { return TGenericExec<TPgDirectFunc<&iclikejoinsel>, true, true, TArgs_iclikejoinsel_Policy>({}); }
+struct TArgs_iclikesel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_float84eq() { return &GenericExec<TPgDirectFunc<&float84eq>, true, true, TArgs_float84eq_Policy>; }
-struct TArgs_float84ge_Policy {
+TExecFunc arrow_iclikesel() { return TGenericExec<TPgDirectFunc<&iclikesel>, true, true, TArgs_iclikesel_Policy>({}); }
+struct TArgs_icnlikejoinsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
 };
-TExecFunc arrow_float84ge() { return &GenericExec<TPgDirectFunc<&float84ge>, true, true, TArgs_float84ge_Policy>; }
-struct TArgs_float84gt_Policy {
+TExecFunc arrow_icnlikejoinsel() { return TGenericExec<TPgDirectFunc<&icnlikejoinsel>, true, true, TArgs_icnlikejoinsel_Policy>({}); }
+struct TArgs_icnlikesel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_float84gt() { return &GenericExec<TPgDirectFunc<&float84gt>, true, true, TArgs_float84gt_Policy>; }
-struct TArgs_float84le_Policy {
+TExecFunc arrow_icnlikesel() { return TGenericExec<TPgDirectFunc<&icnlikesel>, true, true, TArgs_icnlikesel_Policy>({}); }
+struct TArgs_icregexeqjoinsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
 };
-TExecFunc arrow_float84le() { return &GenericExec<TPgDirectFunc<&float84le>, true, true, TArgs_float84le_Policy>; }
-struct TArgs_float84lt_Policy {
+TExecFunc arrow_icregexeqjoinsel() { return TGenericExec<TPgDirectFunc<&icregexeqjoinsel>, true, true, TArgs_icregexeqjoinsel_Policy>({}); }
+struct TArgs_icregexeqsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_float84lt() { return &GenericExec<TPgDirectFunc<&float84lt>, true, true, TArgs_float84lt_Policy>; }
-struct TArgs_float84mi_Policy {
+TExecFunc arrow_icregexeqsel() { return TGenericExec<TPgDirectFunc<&icregexeqsel>, true, true, TArgs_icregexeqsel_Policy>({}); }
+struct TArgs_icregexnejoinsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
 };
-TExecFunc arrow_float84mi() { return &GenericExec<TPgDirectFunc<&float84mi>, true, true, TArgs_float84mi_Policy>; }
-struct TArgs_float84mul_Policy {
+TExecFunc arrow_icregexnejoinsel() { return TGenericExec<TPgDirectFunc<&icregexnejoinsel>, true, true, TArgs_icregexnejoinsel_Policy>({}); }
+struct TArgs_icregexnesel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_float84mul() { return &GenericExec<TPgDirectFunc<&float84mul>, true, true, TArgs_float84mul_Policy>; }
-struct TArgs_float84ne_Policy {
+TExecFunc arrow_icregexnesel() { return TGenericExec<TPgDirectFunc<&icregexnesel>, true, true, TArgs_icregexnesel_Policy>({}); }
+struct TArgs_in_range_interval_interval_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 5> IsFixedArg = {false,false,false,true,true};
 };
-TExecFunc arrow_float84ne() { return &GenericExec<TPgDirectFunc<&float84ne>, true, true, TArgs_float84ne_Policy>; }
-struct TArgs_float84pl_Policy {
+TExecFunc arrow_in_range_interval_interval() { return TGenericExec<TPgDirectFunc<&in_range_interval_interval>, true, true, TArgs_in_range_interval_interval_Policy>({}); }
+struct TArgs_in_range_numeric_numeric_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 5> IsFixedArg = {false,false,false,true,true};
 };
-TExecFunc arrow_float84pl() { return &GenericExec<TPgDirectFunc<&float84pl>, true, true, TArgs_float84pl_Policy>; }
-struct TArgs_float8_accum_Policy {
+TExecFunc arrow_in_range_numeric_numeric() { return TGenericExec<TPgDirectFunc<&in_range_numeric_numeric>, true, true, TArgs_in_range_numeric_numeric_Policy>({}); }
+struct TArgs_in_range_timestamp_interval_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,false,true,true};
 };
-TExecFunc arrow_float8_accum() { return &GenericExec<TPgDirectFunc<&float8_accum>, true, false, TArgs_float8_accum_Policy>; }
-struct TArgs_float8_avg_Policy {
+TExecFunc arrow_in_range_timestamp_interval() { return TGenericExec<TPgDirectFunc<&in_range_timestamp_interval>, true, true, TArgs_in_range_timestamp_interval_Policy>({}); }
+struct TArgs_in_range_timestamptz_interval_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,false,true,true};
 };
-TExecFunc arrow_float8_avg() { return &GenericExec<TPgDirectFunc<&float8_avg>, true, true, TArgs_float8_avg_Policy>; }
-struct TArgs_float8_combine_Policy {
+TExecFunc arrow_in_range_timestamptz_interval() { return TGenericExec<TPgDirectFunc<&in_range_timestamptz_interval>, true, true, TArgs_in_range_timestamptz_interval_Policy>({}); }
+struct TArgs_inet_gist_compress_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_float8_combine() { return &GenericExec<TPgDirectFunc<&float8_combine>, true, false, TArgs_float8_combine_Policy>; }
-struct TArgs_float8_corr_Policy {
+TExecFunc arrow_inet_gist_compress() { return TGenericExec<TPgDirectFunc<&inet_gist_compress>, true, true, TArgs_inet_gist_compress_Policy>({}); }
+struct TArgs_inet_gist_consistent_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,false,true,true,true};
 };
-TExecFunc arrow_float8_corr() { return &GenericExec<TPgDirectFunc<&float8_corr>, true, true, TArgs_float8_corr_Policy>; }
-struct TArgs_float8_covar_pop_Policy {
+TExecFunc arrow_inet_gist_consistent() { return TGenericExec<TPgDirectFunc<&inet_gist_consistent>, true, true, TArgs_inet_gist_consistent_Policy>({}); }
+struct TArgs_inet_gist_fetch_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_float8_covar_pop() { return &GenericExec<TPgDirectFunc<&float8_covar_pop>, true, true, TArgs_float8_covar_pop_Policy>; }
-struct TArgs_float8_covar_samp_Policy {
+TExecFunc arrow_inet_gist_fetch() { return TGenericExec<TPgDirectFunc<&inet_gist_fetch>, true, true, TArgs_inet_gist_fetch_Policy>({}); }
+struct TArgs_inet_gist_penalty_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_float8_covar_samp() { return &GenericExec<TPgDirectFunc<&float8_covar_samp>, true, true, TArgs_float8_covar_samp_Policy>; }
-struct TArgs_float8_regr_accum_Policy {
+TExecFunc arrow_inet_gist_penalty() { return TGenericExec<TPgDirectFunc<&inet_gist_penalty>, true, true, TArgs_inet_gist_penalty_Policy>({}); }
+struct TArgs_inet_gist_picksplit_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_float8_regr_accum() { return &GenericExec<TPgDirectFunc<&float8_regr_accum>, true, false, TArgs_float8_regr_accum_Policy>; }
-struct TArgs_float8_regr_avgx_Policy {
+TExecFunc arrow_inet_gist_picksplit() { return TGenericExec<TPgDirectFunc<&inet_gist_picksplit>, true, true, TArgs_inet_gist_picksplit_Policy>({}); }
+struct TArgs_inet_gist_same_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,true};
 };
-TExecFunc arrow_float8_regr_avgx() { return &GenericExec<TPgDirectFunc<&float8_regr_avgx>, true, true, TArgs_float8_regr_avgx_Policy>; }
-struct TArgs_float8_regr_avgy_Policy {
+TExecFunc arrow_inet_gist_same() { return TGenericExec<TPgDirectFunc<&inet_gist_same>, true, true, TArgs_inet_gist_same_Policy>({}); }
+struct TArgs_inet_gist_union_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_float8_regr_avgy() { return &GenericExec<TPgDirectFunc<&float8_regr_avgy>, true, true, TArgs_float8_regr_avgy_Policy>; }
-struct TArgs_float8_regr_combine_Policy {
+TExecFunc arrow_inet_gist_union() { return TGenericExec<TPgDirectFunc<&inet_gist_union>, true, false, TArgs_inet_gist_union_Policy>({}); }
+struct TArgs_int2_accum_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_float8_regr_combine() { return &GenericExec<TPgDirectFunc<&float8_regr_combine>, true, false, TArgs_float8_regr_combine_Policy>; }
-struct TArgs_float8_regr_intercept_Policy {
+TExecFunc arrow_int2_accum() { return TGenericExec<TPgDirectFunc<&int2_accum>, false, true, TArgs_int2_accum_Policy>({}); }
+struct TArgs_int2_accum_inv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_float8_regr_intercept() { return &GenericExec<TPgDirectFunc<&float8_regr_intercept>, true, true, TArgs_float8_regr_intercept_Policy>; }
-struct TArgs_float8_regr_r2_Policy {
+TExecFunc arrow_int2_accum_inv() { return TGenericExec<TPgDirectFunc<&int2_accum_inv>, false, true, TArgs_int2_accum_inv_Policy>({}); }
+struct TArgs_int2_avg_accum_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_float8_regr_r2() { return &GenericExec<TPgDirectFunc<&float8_regr_r2>, true, true, TArgs_float8_regr_r2_Policy>; }
-struct TArgs_float8_regr_slope_Policy {
+TExecFunc arrow_int2_avg_accum() { return TGenericExec<TPgDirectFunc<&int2_avg_accum>, true, false, TArgs_int2_avg_accum_Policy>({}); }
+struct TArgs_int2_avg_accum_inv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_float8_regr_slope() { return &GenericExec<TPgDirectFunc<&float8_regr_slope>, true, true, TArgs_float8_regr_slope_Policy>; }
-struct TArgs_float8_regr_sxx_Policy {
+TExecFunc arrow_int2_avg_accum_inv() { return TGenericExec<TPgDirectFunc<&int2_avg_accum_inv>, true, false, TArgs_int2_avg_accum_inv_Policy>({}); }
+struct TArgs_int2_mul_cash_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_float8_regr_sxx() { return &GenericExec<TPgDirectFunc<&float8_regr_sxx>, true, true, TArgs_float8_regr_sxx_Policy>; }
-struct TArgs_float8_regr_sxy_Policy {
+TExecFunc arrow_int2_mul_cash() { return TGenericExec<TPgDirectFunc<&int2_mul_cash>, true, true, TArgs_int2_mul_cash_Policy>({}); }
+struct TArgs_int2_numeric_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_float8_regr_sxy() { return &GenericExec<TPgDirectFunc<&float8_regr_sxy>, true, true, TArgs_float8_regr_sxy_Policy>; }
-struct TArgs_float8_regr_syy_Policy {
+TExecFunc arrow_int2_numeric() { return TGenericExec<TPgDirectFunc<&int2_numeric>, true, false, TArgs_int2_numeric_Policy>({}); }
+struct TArgs_int2_sum_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_float8_regr_syy() { return &GenericExec<TPgDirectFunc<&float8_regr_syy>, true, true, TArgs_float8_regr_syy_Policy>; }
-struct TArgs_float8_stddev_pop_Policy {
+TExecFunc arrow_int2_sum() { return TGenericExec<TPgDirectFunc<&int2_sum>, false, true, TArgs_int2_sum_Policy>({}); }
+struct TArgs_int2int4_sum_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_float8_stddev_pop() { return &GenericExec<TPgDirectFunc<&float8_stddev_pop>, true, true, TArgs_float8_stddev_pop_Policy>; }
-struct TArgs_float8_stddev_samp_Policy {
+TExecFunc arrow_int2int4_sum() { return TGenericExec<TPgDirectFunc<&int2int4_sum>, true, true, TArgs_int2int4_sum_Policy>({}); }
+struct TArgs_int4_accum_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_float8_stddev_samp() { return &GenericExec<TPgDirectFunc<&float8_stddev_samp>, true, true, TArgs_float8_stddev_samp_Policy>; }
-struct TArgs_float8_var_pop_Policy {
+TExecFunc arrow_int4_accum() { return TGenericExec<TPgDirectFunc<&int4_accum>, false, true, TArgs_int4_accum_Policy>({}); }
+struct TArgs_int4_accum_inv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_float8_var_pop() { return &GenericExec<TPgDirectFunc<&float8_var_pop>, true, true, TArgs_float8_var_pop_Policy>; }
-struct TArgs_float8_var_samp_Policy {
+TExecFunc arrow_int4_accum_inv() { return TGenericExec<TPgDirectFunc<&int4_accum_inv>, false, true, TArgs_int4_accum_inv_Policy>({}); }
+struct TArgs_int4_avg_accum_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_float8_var_samp() { return &GenericExec<TPgDirectFunc<&float8_var_samp>, true, true, TArgs_float8_var_samp_Policy>; }
-struct TArgs_float8abs_Policy {
+TExecFunc arrow_int4_avg_accum() { return TGenericExec<TPgDirectFunc<&int4_avg_accum>, true, false, TArgs_int4_avg_accum_Policy>({}); }
+struct TArgs_int4_avg_accum_inv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_float8abs() { return &GenericExec<TPgDirectFunc<&float8abs>, true, true, TArgs_float8abs_Policy>; }
-struct TArgs_float8div_Policy {
+TExecFunc arrow_int4_avg_accum_inv() { return TGenericExec<TPgDirectFunc<&int4_avg_accum_inv>, true, false, TArgs_int4_avg_accum_inv_Policy>({}); }
+struct TArgs_int4_avg_combine_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_float8div() { return &GenericExec<TPgDirectFunc<&float8div>, true, true, TArgs_float8div_Policy>; }
-struct TArgs_float8eq_Policy {
+TExecFunc arrow_int4_avg_combine() { return TGenericExec<TPgDirectFunc<&int4_avg_combine>, true, false, TArgs_int4_avg_combine_Policy>({}); }
+struct TArgs_int4_cash_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_float8eq() { return &GenericExec<TPgDirectFunc<&float8eq>, true, true, TArgs_float8eq_Policy>; }
-struct TArgs_float8ge_Policy {
+TExecFunc arrow_int4_cash() { return TGenericExec<TPgDirectFunc<&int4_cash>, true, true, TArgs_int4_cash_Policy>({}); }
+struct TArgs_int4_mul_cash_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_float8ge() { return &GenericExec<TPgDirectFunc<&float8ge>, true, true, TArgs_float8ge_Policy>; }
-struct TArgs_float8gt_Policy {
+TExecFunc arrow_int4_mul_cash() { return TGenericExec<TPgDirectFunc<&int4_mul_cash>, true, true, TArgs_int4_mul_cash_Policy>({}); }
+struct TArgs_int4_numeric_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_float8gt() { return &GenericExec<TPgDirectFunc<&float8gt>, true, true, TArgs_float8gt_Policy>; }
-struct TArgs_float8in_Policy {
+TExecFunc arrow_int4_numeric() { return TGenericExec<TPgDirectFunc<&int4_numeric>, true, false, TArgs_int4_numeric_Policy>({}); }
+struct TArgs_int4_sum_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_float8in() { return &GenericExec<TPgDirectFunc<&float8in>, true, true, TArgs_float8in_Policy>; }
-struct TArgs_float8larger_Policy {
+TExecFunc arrow_int4_sum() { return TGenericExec<TPgDirectFunc<&int4_sum>, false, true, TArgs_int4_sum_Policy>({}); }
+struct TArgs_int4_to_char_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_float8larger() { return &GenericExec<TPgDirectFunc<&float8larger>, true, true, TArgs_float8larger_Policy>; }
-struct TArgs_float8le_Policy {
+TExecFunc arrow_int4_to_char() { return TGenericExec<TPgDirectFunc<&int4_to_char>, true, false, TArgs_int4_to_char_Policy>({}); }
+struct TArgs_int8_accum_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_float8le() { return &GenericExec<TPgDirectFunc<&float8le>, true, true, TArgs_float8le_Policy>; }
-struct TArgs_float8lt_Policy {
+TExecFunc arrow_int8_accum() { return TGenericExec<TPgDirectFunc<&int8_accum>, false, true, TArgs_int8_accum_Policy>({}); }
+struct TArgs_int8_accum_inv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_float8lt() { return &GenericExec<TPgDirectFunc<&float8lt>, true, true, TArgs_float8lt_Policy>; }
-struct TArgs_float8mi_Policy {
+TExecFunc arrow_int8_accum_inv() { return TGenericExec<TPgDirectFunc<&int8_accum_inv>, false, true, TArgs_int8_accum_inv_Policy>({}); }
+struct TArgs_int8_avg_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_float8mi() { return &GenericExec<TPgDirectFunc<&float8mi>, true, true, TArgs_float8mi_Policy>; }
-struct TArgs_float8mul_Policy {
+TExecFunc arrow_int8_avg() { return TGenericExec<TPgDirectFunc<&int8_avg>, true, false, TArgs_int8_avg_Policy>({}); }
+struct TArgs_int8_avg_accum_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_float8mul() { return &GenericExec<TPgDirectFunc<&float8mul>, true, true, TArgs_float8mul_Policy>; }
-struct TArgs_float8ne_Policy {
+TExecFunc arrow_int8_avg_accum() { return TGenericExec<TPgDirectFunc<&int8_avg_accum>, false, true, TArgs_int8_avg_accum_Policy>({}); }
+struct TArgs_int8_avg_accum_inv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_float8ne() { return &GenericExec<TPgDirectFunc<&float8ne>, true, true, TArgs_float8ne_Policy>; }
-struct TArgs_float8out_Policy {
+TExecFunc arrow_int8_avg_accum_inv() { return TGenericExec<TPgDirectFunc<&int8_avg_accum_inv>, false, true, TArgs_int8_avg_accum_inv_Policy>({}); }
+struct TArgs_int8_avg_combine_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_float8out() { return &GenericExec<TPgDirectFunc<&float8out>, true, false, TArgs_float8out_Policy>; }
-struct TArgs_float8pl_Policy {
+TExecFunc arrow_int8_avg_combine() { return TGenericExec<TPgDirectFunc<&int8_avg_combine>, false, true, TArgs_int8_avg_combine_Policy>({}); }
+struct TArgs_int8_avg_deserialize_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_float8pl() { return &GenericExec<TPgDirectFunc<&float8pl>, true, true, TArgs_float8pl_Policy>; }
-struct TArgs_float8recv_Policy {
+TExecFunc arrow_int8_avg_deserialize() { return TGenericExec<TPgDirectFunc<&int8_avg_deserialize>, true, true, TArgs_int8_avg_deserialize_Policy>({}); }
+struct TArgs_int8_avg_serialize_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_float8recv() { return &GenericExec<TPgDirectFunc<&float8recv>, true, true, TArgs_float8recv_Policy>; }
-struct TArgs_float8send_Policy {
+TExecFunc arrow_int8_avg_serialize() { return TGenericExec<TPgDirectFunc<&int8_avg_serialize>, true, false, TArgs_int8_avg_serialize_Policy>({}); }
+struct TArgs_int8_cash_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_float8send() { return &GenericExec<TPgDirectFunc<&float8send>, true, false, TArgs_float8send_Policy>; }
-struct TArgs_float8smaller_Policy {
+TExecFunc arrow_int8_cash() { return TGenericExec<TPgDirectFunc<&int8_cash>, true, true, TArgs_int8_cash_Policy>({}); }
+struct TArgs_int8_mul_cash_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_float8smaller() { return &GenericExec<TPgDirectFunc<&float8smaller>, true, true, TArgs_float8smaller_Policy>; }
-struct TArgs_float8um_Policy {
+TExecFunc arrow_int8_mul_cash() { return TGenericExec<TPgDirectFunc<&int8_mul_cash>, true, true, TArgs_int8_mul_cash_Policy>({}); }
+struct TArgs_int8_numeric_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_float8um() { return &GenericExec<TPgDirectFunc<&float8um>, true, true, TArgs_float8um_Policy>; }
-struct TArgs_float8up_Policy {
+TExecFunc arrow_int8_numeric() { return TGenericExec<TPgDirectFunc<&int8_numeric>, true, false, TArgs_int8_numeric_Policy>({}); }
+struct TArgs_int8_sum_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_float8up() { return &GenericExec<TPgDirectFunc<&float8up>, true, true, TArgs_float8up_Policy>; }
-struct TArgs_flt4_mul_cash_Policy {
+TExecFunc arrow_int8_sum() { return TGenericExec<TPgDirectFunc<&int8_sum>, false, false, TArgs_int8_sum_Policy>({}); }
+struct TArgs_int8_to_char_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_flt4_mul_cash() { return &GenericExec<TPgDirectFunc<&flt4_mul_cash>, true, true, TArgs_flt4_mul_cash_Policy>; }
-struct TArgs_flt8_mul_cash_Policy {
+TExecFunc arrow_int8_to_char() { return TGenericExec<TPgDirectFunc<&int8_to_char>, true, false, TArgs_int8_to_char_Policy>({}); }
+struct TArgs_inter_lb_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_flt8_mul_cash() { return &GenericExec<TPgDirectFunc<&flt8_mul_cash>, true, true, TArgs_flt8_mul_cash_Policy>; }
-struct TArgs_format_type_Policy {
+TExecFunc arrow_inter_lb() { return TGenericExec<TPgDirectFunc<&inter_lb>, true, true, TArgs_inter_lb_Policy>({}); }
+struct TArgs_inter_sb_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_format_type() { return &GenericExec<TPgDirectFunc<&format_type>, false, false, TArgs_format_type_Policy>; }
-struct TArgs_ftod_Policy {
+TExecFunc arrow_inter_sb() { return TGenericExec<TPgDirectFunc<&inter_sb>, true, true, TArgs_inter_sb_Policy>({}); }
+struct TArgs_inter_sl_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_ftod() { return &GenericExec<TPgDirectFunc<&ftod>, true, true, TArgs_ftod_Policy>; }
-struct TArgs_ftoi2_Policy {
+TExecFunc arrow_inter_sl() { return TGenericExec<TPgDirectFunc<&inter_sl>, true, true, TArgs_inter_sl_Policy>({}); }
+struct TArgs_interval_accum_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_ftoi2() { return &GenericExec<TPgDirectFunc<&ftoi2>, true, true, TArgs_ftoi2_Policy>; }
-struct TArgs_ftoi4_Policy {
+TExecFunc arrow_interval_accum() { return TGenericExec<TPgDirectFunc<&interval_accum>, true, false, TArgs_interval_accum_Policy>({}); }
+struct TArgs_interval_accum_inv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_ftoi4() { return &GenericExec<TPgDirectFunc<&ftoi4>, true, true, TArgs_ftoi4_Policy>; }
-struct TArgs_ginarrayconsistent_Policy {
+TExecFunc arrow_interval_accum_inv() { return TGenericExec<TPgDirectFunc<&interval_accum_inv>, true, false, TArgs_interval_accum_inv_Policy>({}); }
+struct TArgs_interval_avg_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 8> IsFixedArg = {true,true,false,true,true,true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_ginarrayconsistent() { return &GenericExec<TPgDirectFunc<&ginarrayconsistent>, true, true, TArgs_ginarrayconsistent_Policy>; }
-struct TArgs_ginarrayextract_Policy {
+TExecFunc arrow_interval_avg() { return TGenericExec<TPgDirectFunc<&interval_avg>, true, false, TArgs_interval_avg_Policy>({}); }
+struct TArgs_interval_cmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_ginarrayextract() { return &GenericExec<TPgDirectFunc<&ginarrayextract>, true, true, TArgs_ginarrayextract_Policy>; }
-struct TArgs_ginarrayextract_2args_Policy {
+TExecFunc arrow_interval_cmp() { return TGenericExec<TPgDirectFunc<&interval_cmp>, true, true, TArgs_interval_cmp_Policy>({}); }
+struct TArgs_interval_combine_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_interval_combine() { return TGenericExec<TPgDirectFunc<&interval_combine>, true, false, TArgs_interval_combine_Policy>({}); }
+struct TArgs_interval_div_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_ginarrayextract_2args() { return &GenericExec<TPgDirectFunc<&ginarrayextract_2args>, true, true, TArgs_ginarrayextract_2args_Policy>; }
-struct TArgs_ginarraytriconsistent_Policy {
+TExecFunc arrow_interval_div() { return TGenericExec<TPgDirectFunc<&interval_div>, true, false, TArgs_interval_div_Policy>({}); }
+struct TArgs_interval_eq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 7> IsFixedArg = {true,true,false,true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_ginarraytriconsistent() { return &GenericExec<TPgDirectFunc<&ginarraytriconsistent>, true, true, TArgs_ginarraytriconsistent_Policy>; }
-struct TArgs_ginhandler_Policy {
+TExecFunc arrow_interval_eq() { return TGenericExec<TPgDirectFunc<&interval_eq>, true, true, TArgs_interval_eq_Policy>({}); }
+struct TArgs_interval_finite_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_ginhandler() { return &GenericExec<TPgDirectFunc<&ginhandler>, true, true, TArgs_ginhandler_Policy>; }
-struct TArgs_ginqueryarrayextract_Policy {
+TExecFunc arrow_interval_finite() { return TGenericExec<TPgDirectFunc<&interval_finite>, true, true, TArgs_interval_finite_Policy>({}); }
+struct TArgs_interval_ge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 7> IsFixedArg = {false,true,true,true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_interval_ge() { return TGenericExec<TPgDirectFunc<&interval_ge>, true, true, TArgs_interval_ge_Policy>({}); }
+struct TArgs_interval_gt_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_ginqueryarrayextract() { return &GenericExec<TPgDirectFunc<&ginqueryarrayextract>, true, true, TArgs_ginqueryarrayextract_Policy>; }
-struct TArgs_hash_multirange_Policy {
+TExecFunc arrow_interval_gt() { return TGenericExec<TPgDirectFunc<&interval_gt>, true, true, TArgs_interval_gt_Policy>({}); }
+struct TArgs_interval_hash_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_hash_multirange() { return &GenericExec<TPgDirectFunc<&hash_multirange>, true, true, TArgs_hash_multirange_Policy>; }
-struct TArgs_hash_multirange_extended_Policy {
+TExecFunc arrow_interval_hash() { return TGenericExec<TPgDirectFunc<&interval_hash>, true, true, TArgs_interval_hash_Policy>({}); }
+struct TArgs_interval_hash_extended_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_hash_multirange_extended() { return &GenericExec<TPgDirectFunc<&hash_multirange_extended>, true, true, TArgs_hash_multirange_extended_Policy>; }
-struct TArgs_i2tod_Policy {
+TExecFunc arrow_interval_hash_extended() { return TGenericExec<TPgDirectFunc<&interval_hash_extended>, true, true, TArgs_interval_hash_extended_Policy>({}); }
+struct TArgs_interval_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_i2tod() { return &GenericExec<TPgDirectFunc<&i2tod>, true, true, TArgs_i2tod_Policy>; }
-struct TArgs_i2tof_Policy {
+TExecFunc arrow_interval_in() { return TGenericExec<TPgDirectFunc<&interval_in>, true, false, TArgs_interval_in_Policy>({}); }
+struct TArgs_interval_justify_days_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_i2tof() { return &GenericExec<TPgDirectFunc<&i2tof>, true, true, TArgs_i2tof_Policy>; }
-struct TArgs_i4tochar_Policy {
+TExecFunc arrow_interval_justify_days() { return TGenericExec<TPgDirectFunc<&interval_justify_days>, true, false, TArgs_interval_justify_days_Policy>({}); }
+struct TArgs_interval_justify_hours_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_i4tochar() { return &GenericExec<TPgDirectFunc<&i4tochar>, true, true, TArgs_i4tochar_Policy>; }
-struct TArgs_i4tod_Policy {
+TExecFunc arrow_interval_justify_hours() { return TGenericExec<TPgDirectFunc<&interval_justify_hours>, true, false, TArgs_interval_justify_hours_Policy>({}); }
+struct TArgs_interval_justify_interval_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_i4tod() { return &GenericExec<TPgDirectFunc<&i4tod>, true, true, TArgs_i4tod_Policy>; }
-struct TArgs_i4tof_Policy {
+TExecFunc arrow_interval_justify_interval() { return TGenericExec<TPgDirectFunc<&interval_justify_interval>, true, false, TArgs_interval_justify_interval_Policy>({}); }
+struct TArgs_interval_larger_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_i4tof() { return &GenericExec<TPgDirectFunc<&i4tof>, true, true, TArgs_i4tof_Policy>; }
-struct TArgs_in_range_float4_float8_Policy {
+TExecFunc arrow_interval_larger() { return TGenericExec<TPgDirectFunc<&interval_larger>, true, false, TArgs_interval_larger_Policy>({}); }
+struct TArgs_interval_le_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_in_range_float4_float8() { return &GenericExec<TPgDirectFunc<&in_range_float4_float8>, true, true, TArgs_in_range_float4_float8_Policy>; }
-struct TArgs_in_range_float8_float8_Policy {
+TExecFunc arrow_interval_le() { return TGenericExec<TPgDirectFunc<&interval_le>, true, true, TArgs_interval_le_Policy>({}); }
+struct TArgs_interval_lt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_in_range_float8_float8() { return &GenericExec<TPgDirectFunc<&in_range_float8_float8>, true, true, TArgs_in_range_float8_float8_Policy>; }
-struct TArgs_int2_mul_cash_Policy {
+TExecFunc arrow_interval_lt() { return TGenericExec<TPgDirectFunc<&interval_lt>, true, true, TArgs_interval_lt_Policy>({}); }
+struct TArgs_interval_mi_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_int2_mul_cash() { return &GenericExec<TPgDirectFunc<&int2_mul_cash>, true, true, TArgs_int2_mul_cash_Policy>; }
-struct TArgs_int4_cash_Policy {
+TExecFunc arrow_interval_mi() { return TGenericExec<TPgDirectFunc<&interval_mi>, true, false, TArgs_interval_mi_Policy>({}); }
+struct TArgs_interval_mul_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_int4_cash() { return &GenericExec<TPgDirectFunc<&int4_cash>, true, true, TArgs_int4_cash_Policy>; }
-struct TArgs_int4_mul_cash_Policy {
+TExecFunc arrow_interval_mul() { return TGenericExec<TPgDirectFunc<&interval_mul>, true, false, TArgs_interval_mul_Policy>({}); }
+struct TArgs_interval_ne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_int4_mul_cash() { return &GenericExec<TPgDirectFunc<&int4_mul_cash>, true, true, TArgs_int4_mul_cash_Policy>; }
-struct TArgs_int8_cash_Policy {
+TExecFunc arrow_interval_ne() { return TGenericExec<TPgDirectFunc<&interval_ne>, true, true, TArgs_interval_ne_Policy>({}); }
+struct TArgs_interval_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_int8_cash() { return &GenericExec<TPgDirectFunc<&int8_cash>, true, true, TArgs_int8_cash_Policy>; }
-struct TArgs_int8_mul_cash_Policy {
+TExecFunc arrow_interval_out() { return TGenericExec<TPgDirectFunc<&interval_out>, true, false, TArgs_interval_out_Policy>({}); }
+struct TArgs_interval_part_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_int8_mul_cash() { return &GenericExec<TPgDirectFunc<&int8_mul_cash>, true, true, TArgs_int8_mul_cash_Policy>; }
-struct TArgs_json_array_element_Policy {
+TExecFunc arrow_interval_part() { return TGenericExec<TPgDirectFunc<&interval_part>, true, true, TArgs_interval_part_Policy>({}); }
+struct TArgs_interval_pl_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_interval_pl() { return TGenericExec<TPgDirectFunc<&interval_pl>, true, false, TArgs_interval_pl_Policy>({}); }
+struct TArgs_interval_recv_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_json_array_element() { return &GenericExec<TPgDirectFunc<&json_array_element>, true, false, TArgs_json_array_element_Policy>; }
-struct TArgs_json_array_element_text_Policy {
+TExecFunc arrow_interval_recv() { return TGenericExec<TPgDirectFunc<&interval_recv>, true, false, TArgs_interval_recv_Policy>({}); }
+struct TArgs_interval_scale_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_json_array_element_text() { return &GenericExec<TPgDirectFunc<&json_array_element_text>, true, false, TArgs_json_array_element_text_Policy>; }
-struct TArgs_json_array_length_Policy {
+TExecFunc arrow_interval_scale() { return TGenericExec<TPgDirectFunc<&interval_scale>, true, false, TArgs_interval_scale_Policy>({}); }
+struct TArgs_interval_send_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_json_array_length() { return &GenericExec<TPgDirectFunc<&json_array_length>, true, true, TArgs_json_array_length_Policy>; }
-struct TArgs_json_object_field_Policy {
+TExecFunc arrow_interval_send() { return TGenericExec<TPgDirectFunc<&interval_send>, true, false, TArgs_interval_send_Policy>({}); }
+struct TArgs_interval_smaller_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_json_object_field() { return &GenericExec<TPgDirectFunc<&json_object_field>, true, false, TArgs_json_object_field_Policy>; }
-struct TArgs_json_object_field_text_Policy {
+TExecFunc arrow_interval_smaller() { return TGenericExec<TPgDirectFunc<&interval_smaller>, true, false, TArgs_interval_smaller_Policy>({}); }
+struct TArgs_interval_support_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_interval_support() { return TGenericExec<TPgDirectFunc<&interval_support>, true, true, TArgs_interval_support_Policy>({}); }
+struct TArgs_interval_to_char_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_json_object_field_text() { return &GenericExec<TPgDirectFunc<&json_object_field_text>, true, false, TArgs_json_object_field_text_Policy>; }
-struct TArgs_json_populate_record_Policy {
+TExecFunc arrow_interval_to_char() { return TGenericExec<TPgDirectFunc<&interval_to_char>, true, false, TArgs_interval_to_char_Policy>({}); }
+struct TArgs_interval_trunc_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_json_populate_record() { return &GenericExec<TPgDirectFunc<&json_populate_record>, false, true, TArgs_json_populate_record_Policy>; }
-struct TArgs_json_strip_nulls_Policy {
+TExecFunc arrow_interval_trunc() { return TGenericExec<TPgDirectFunc<&interval_trunc>, true, false, TArgs_interval_trunc_Policy>({}); }
+struct TArgs_interval_um_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_json_strip_nulls() { return &GenericExec<TPgDirectFunc<&json_strip_nulls>, true, false, TArgs_json_strip_nulls_Policy>; }
-struct TArgs_json_to_record_Policy {
+TExecFunc arrow_interval_um() { return TGenericExec<TPgDirectFunc<&interval_um>, true, false, TArgs_interval_um_Policy>({}); }
+struct TArgs_intervaltypmodin_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_json_to_record() { return &GenericExec<TPgDirectFunc<&json_to_record>, true, false, TArgs_json_to_record_Policy>; }
-struct TArgs_jsonb_array_element_Policy {
+TExecFunc arrow_intervaltypmodin() { return TGenericExec<TPgDirectFunc<&intervaltypmodin>, true, true, TArgs_intervaltypmodin_Policy>({}); }
+struct TArgs_intervaltypmodout_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_jsonb_array_element() { return &GenericExec<TPgDirectFunc<&jsonb_array_element>, true, false, TArgs_jsonb_array_element_Policy>; }
-struct TArgs_jsonb_array_element_text_Policy {
+TExecFunc arrow_intervaltypmodout() { return TGenericExec<TPgDirectFunc<&intervaltypmodout>, true, false, TArgs_intervaltypmodout_Policy>({}); }
+struct TArgs_likejoinsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
 };
-TExecFunc arrow_jsonb_array_element_text() { return &GenericExec<TPgDirectFunc<&jsonb_array_element_text>, true, false, TArgs_jsonb_array_element_text_Policy>; }
-struct TArgs_jsonb_array_length_Policy {
+TExecFunc arrow_likejoinsel() { return TGenericExec<TPgDirectFunc<&likejoinsel>, true, true, TArgs_likejoinsel_Policy>({}); }
+struct TArgs_likesel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_jsonb_array_length() { return &GenericExec<TPgDirectFunc<&jsonb_array_length>, true, true, TArgs_jsonb_array_length_Policy>; }
-struct TArgs_jsonb_cmp_Policy {
+TExecFunc arrow_likesel() { return TGenericExec<TPgDirectFunc<&likesel>, true, true, TArgs_likesel_Policy>({}); }
+struct TArgs_line_construct_pp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_jsonb_cmp() { return &GenericExec<TPgDirectFunc<&jsonb_cmp>, true, true, TArgs_jsonb_cmp_Policy>; }
-struct TArgs_jsonb_concat_Policy {
+TExecFunc arrow_line_construct_pp() { return TGenericExec<TPgDirectFunc<&line_construct_pp>, true, false, TArgs_line_construct_pp_Policy>({}); }
+struct TArgs_line_distance_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_jsonb_concat() { return &GenericExec<TPgDirectFunc<&jsonb_concat>, true, false, TArgs_jsonb_concat_Policy>; }
-struct TArgs_jsonb_contained_Policy {
+TExecFunc arrow_line_distance() { return TGenericExec<TPgDirectFunc<&line_distance>, true, true, TArgs_line_distance_Policy>({}); }
+struct TArgs_line_eq_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_jsonb_contained() { return &GenericExec<TPgDirectFunc<&jsonb_contained>, true, true, TArgs_jsonb_contained_Policy>; }
-struct TArgs_jsonb_contains_Policy {
+TExecFunc arrow_line_eq() { return TGenericExec<TPgDirectFunc<&line_eq>, true, true, TArgs_line_eq_Policy>({}); }
+struct TArgs_line_horizontal_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_line_horizontal() { return TGenericExec<TPgDirectFunc<&line_horizontal>, true, true, TArgs_line_horizontal_Policy>({}); }
+struct TArgs_line_in_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_line_in() { return TGenericExec<TPgDirectFunc<&line_in>, true, false, TArgs_line_in_Policy>({}); }
+struct TArgs_line_interpt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_jsonb_contains() { return &GenericExec<TPgDirectFunc<&jsonb_contains>, true, true, TArgs_jsonb_contains_Policy>; }
-struct TArgs_jsonb_delete_Policy {
+TExecFunc arrow_line_interpt() { return TGenericExec<TPgDirectFunc<&line_interpt>, true, false, TArgs_line_interpt_Policy>({}); }
+struct TArgs_line_intersect_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_jsonb_delete() { return &GenericExec<TPgDirectFunc<&jsonb_delete>, true, false, TArgs_jsonb_delete_Policy>; }
-struct TArgs_jsonb_delete_idx_Policy {
+TExecFunc arrow_line_intersect() { return TGenericExec<TPgDirectFunc<&line_intersect>, true, true, TArgs_line_intersect_Policy>({}); }
+struct TArgs_line_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_jsonb_delete_idx() { return &GenericExec<TPgDirectFunc<&jsonb_delete_idx>, true, false, TArgs_jsonb_delete_idx_Policy>; }
-struct TArgs_jsonb_delete_path_Policy {
+TExecFunc arrow_line_out() { return TGenericExec<TPgDirectFunc<&line_out>, true, false, TArgs_line_out_Policy>({}); }
+struct TArgs_line_parallel_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_jsonb_delete_path() { return &GenericExec<TPgDirectFunc<&jsonb_delete_path>, true, false, TArgs_jsonb_delete_path_Policy>; }
-struct TArgs_jsonb_eq_Policy {
+TExecFunc arrow_line_parallel() { return TGenericExec<TPgDirectFunc<&line_parallel>, true, true, TArgs_line_parallel_Policy>({}); }
+struct TArgs_line_perp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_jsonb_eq() { return &GenericExec<TPgDirectFunc<&jsonb_eq>, true, true, TArgs_jsonb_eq_Policy>; }
-struct TArgs_jsonb_exists_Policy {
+TExecFunc arrow_line_perp() { return TGenericExec<TPgDirectFunc<&line_perp>, true, true, TArgs_line_perp_Policy>({}); }
+struct TArgs_line_recv_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_line_recv() { return TGenericExec<TPgDirectFunc<&line_recv>, true, false, TArgs_line_recv_Policy>({}); }
+struct TArgs_line_send_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_line_send() { return TGenericExec<TPgDirectFunc<&line_send>, true, false, TArgs_line_send_Policy>({}); }
+struct TArgs_line_vertical_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_line_vertical() { return TGenericExec<TPgDirectFunc<&line_vertical>, true, true, TArgs_line_vertical_Policy>({}); }
+struct TArgs_lseg_center_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_lseg_center() { return TGenericExec<TPgDirectFunc<&lseg_center>, true, false, TArgs_lseg_center_Policy>({}); }
+struct TArgs_lseg_construct_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_jsonb_exists() { return &GenericExec<TPgDirectFunc<&jsonb_exists>, true, true, TArgs_jsonb_exists_Policy>; }
-struct TArgs_jsonb_exists_all_Policy {
+TExecFunc arrow_lseg_construct() { return TGenericExec<TPgDirectFunc<&lseg_construct>, true, false, TArgs_lseg_construct_Policy>({}); }
+struct TArgs_lseg_distance_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_jsonb_exists_all() { return &GenericExec<TPgDirectFunc<&jsonb_exists_all>, true, true, TArgs_jsonb_exists_all_Policy>; }
-struct TArgs_jsonb_exists_any_Policy {
+TExecFunc arrow_lseg_distance() { return TGenericExec<TPgDirectFunc<&lseg_distance>, true, true, TArgs_lseg_distance_Policy>({}); }
+struct TArgs_lseg_eq_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_jsonb_exists_any() { return &GenericExec<TPgDirectFunc<&jsonb_exists_any>, true, true, TArgs_jsonb_exists_any_Policy>; }
-struct TArgs_jsonb_ge_Policy {
+TExecFunc arrow_lseg_eq() { return TGenericExec<TPgDirectFunc<&lseg_eq>, true, true, TArgs_lseg_eq_Policy>({}); }
+struct TArgs_lseg_ge_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_jsonb_ge() { return &GenericExec<TPgDirectFunc<&jsonb_ge>, true, true, TArgs_jsonb_ge_Policy>; }
-struct TArgs_jsonb_gt_Policy {
+TExecFunc arrow_lseg_ge() { return TGenericExec<TPgDirectFunc<&lseg_ge>, true, true, TArgs_lseg_ge_Policy>({}); }
+struct TArgs_lseg_gt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_jsonb_gt() { return &GenericExec<TPgDirectFunc<&jsonb_gt>, true, true, TArgs_jsonb_gt_Policy>; }
-struct TArgs_jsonb_hash_Policy {
+TExecFunc arrow_lseg_gt() { return TGenericExec<TPgDirectFunc<&lseg_gt>, true, true, TArgs_lseg_gt_Policy>({}); }
+struct TArgs_lseg_horizontal_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_jsonb_hash() { return &GenericExec<TPgDirectFunc<&jsonb_hash>, true, true, TArgs_jsonb_hash_Policy>; }
-struct TArgs_jsonb_hash_extended_Policy {
+TExecFunc arrow_lseg_horizontal() { return TGenericExec<TPgDirectFunc<&lseg_horizontal>, true, true, TArgs_lseg_horizontal_Policy>({}); }
+struct TArgs_lseg_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_jsonb_hash_extended() { return &GenericExec<TPgDirectFunc<&jsonb_hash_extended>, true, true, TArgs_jsonb_hash_extended_Policy>; }
-struct TArgs_jsonb_insert_Policy {
+TExecFunc arrow_lseg_in() { return TGenericExec<TPgDirectFunc<&lseg_in>, true, false, TArgs_lseg_in_Policy>({}); }
+struct TArgs_lseg_interpt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_jsonb_insert() { return &GenericExec<TPgDirectFunc<&jsonb_insert>, true, false, TArgs_jsonb_insert_Policy>; }
-struct TArgs_jsonb_le_Policy {
+TExecFunc arrow_lseg_interpt() { return TGenericExec<TPgDirectFunc<&lseg_interpt>, true, false, TArgs_lseg_interpt_Policy>({}); }
+struct TArgs_lseg_intersect_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_jsonb_le() { return &GenericExec<TPgDirectFunc<&jsonb_le>, true, true, TArgs_jsonb_le_Policy>; }
-struct TArgs_jsonb_lt_Policy {
+TExecFunc arrow_lseg_intersect() { return TGenericExec<TPgDirectFunc<&lseg_intersect>, true, true, TArgs_lseg_intersect_Policy>({}); }
+struct TArgs_lseg_le_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_jsonb_lt() { return &GenericExec<TPgDirectFunc<&jsonb_lt>, true, true, TArgs_jsonb_lt_Policy>; }
-struct TArgs_jsonb_ne_Policy {
+TExecFunc arrow_lseg_le() { return TGenericExec<TPgDirectFunc<&lseg_le>, true, true, TArgs_lseg_le_Policy>({}); }
+struct TArgs_lseg_length_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_jsonb_ne() { return &GenericExec<TPgDirectFunc<&jsonb_ne>, true, true, TArgs_jsonb_ne_Policy>; }
-struct TArgs_jsonb_object_field_Policy {
+TExecFunc arrow_lseg_length() { return TGenericExec<TPgDirectFunc<&lseg_length>, true, true, TArgs_lseg_length_Policy>({}); }
+struct TArgs_lseg_lt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_jsonb_object_field() { return &GenericExec<TPgDirectFunc<&jsonb_object_field>, true, false, TArgs_jsonb_object_field_Policy>; }
-struct TArgs_jsonb_object_field_text_Policy {
+TExecFunc arrow_lseg_lt() { return TGenericExec<TPgDirectFunc<&lseg_lt>, true, true, TArgs_lseg_lt_Policy>({}); }
+struct TArgs_lseg_ne_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_jsonb_object_field_text() { return &GenericExec<TPgDirectFunc<&jsonb_object_field_text>, true, false, TArgs_jsonb_object_field_text_Policy>; }
-struct TArgs_jsonb_populate_record_Policy {
+TExecFunc arrow_lseg_ne() { return TGenericExec<TPgDirectFunc<&lseg_ne>, true, true, TArgs_lseg_ne_Policy>({}); }
+struct TArgs_lseg_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_jsonb_populate_record() { return &GenericExec<TPgDirectFunc<&jsonb_populate_record>, false, true, TArgs_jsonb_populate_record_Policy>; }
-struct TArgs_jsonb_pretty_Policy {
+TExecFunc arrow_lseg_out() { return TGenericExec<TPgDirectFunc<&lseg_out>, true, false, TArgs_lseg_out_Policy>({}); }
+struct TArgs_lseg_parallel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_jsonb_pretty() { return &GenericExec<TPgDirectFunc<&jsonb_pretty>, true, false, TArgs_jsonb_pretty_Policy>; }
-struct TArgs_jsonb_set_Policy {
+TExecFunc arrow_lseg_parallel() { return TGenericExec<TPgDirectFunc<&lseg_parallel>, true, true, TArgs_lseg_parallel_Policy>({}); }
+struct TArgs_lseg_perp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_jsonb_set() { return &GenericExec<TPgDirectFunc<&jsonb_set>, true, false, TArgs_jsonb_set_Policy>; }
-struct TArgs_jsonb_set_lax_Policy {
+TExecFunc arrow_lseg_perp() { return TGenericExec<TPgDirectFunc<&lseg_perp>, true, true, TArgs_lseg_perp_Policy>({}); }
+struct TArgs_lseg_recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 5> IsFixedArg = {false,false,false,true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_jsonb_set_lax() { return &GenericExec<TPgDirectFunc<&jsonb_set_lax>, false, false, TArgs_jsonb_set_lax_Policy>; }
-struct TArgs_jsonb_strip_nulls_Policy {
+TExecFunc arrow_lseg_recv() { return TGenericExec<TPgDirectFunc<&lseg_recv>, true, false, TArgs_lseg_recv_Policy>({}); }
+struct TArgs_lseg_send_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_jsonb_strip_nulls() { return &GenericExec<TPgDirectFunc<&jsonb_strip_nulls>, true, false, TArgs_jsonb_strip_nulls_Policy>; }
-struct TArgs_jsonb_to_record_Policy {
+TExecFunc arrow_lseg_send() { return TGenericExec<TPgDirectFunc<&lseg_send>, true, false, TArgs_lseg_send_Policy>({}); }
+struct TArgs_lseg_vertical_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_jsonb_to_record() { return &GenericExec<TPgDirectFunc<&jsonb_to_record>, true, false, TArgs_jsonb_to_record_Policy>; }
-struct TArgs_jsonpath_in_Policy {
+TExecFunc arrow_lseg_vertical() { return TGenericExec<TPgDirectFunc<&lseg_vertical>, true, true, TArgs_lseg_vertical_Policy>({}); }
+struct TArgs_make_interval_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 7> IsFixedArg = {true,true,true,true,true,true,true};
+};
+TExecFunc arrow_make_interval() { return TGenericExec<TPgDirectFunc<&make_interval>, true, false, TArgs_make_interval_Policy>({}); }
+struct TArgs_make_timestamp_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 6> IsFixedArg = {true,true,true,true,true,true};
+};
+TExecFunc arrow_make_timestamp() { return TGenericExec<TPgDirectFunc<&make_timestamp>, true, true, TArgs_make_timestamp_Policy>({}); }
+struct TArgs_make_timestamptz_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 6> IsFixedArg = {true,true,true,true,true,true};
+};
+TExecFunc arrow_make_timestamptz() { return TGenericExec<TPgDirectFunc<&make_timestamptz>, true, true, TArgs_make_timestamptz_Policy>({}); }
+struct TArgs_make_timestamptz_at_timezone_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 7> IsFixedArg = {true,true,true,true,true,true,false};
+};
+TExecFunc arrow_make_timestamptz_at_timezone() { return TGenericExec<TPgDirectFunc<&make_timestamptz_at_timezone>, true, true, TArgs_make_timestamptz_at_timezone_Policy>({}); }
+struct TArgs_md5_bytea_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_jsonpath_in() { return &GenericExec<TPgDirectFunc<&jsonpath_in>, true, false, TArgs_jsonpath_in_Policy>; }
-struct TArgs_jsonpath_out_Policy {
+TExecFunc arrow_md5_bytea() { return TGenericExec<TPgDirectFunc<&md5_bytea>, true, false, TArgs_md5_bytea_Policy>({}); }
+struct TArgs_md5_text_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_jsonpath_out() { return &GenericExec<TPgDirectFunc<&jsonpath_out>, true, false, TArgs_jsonpath_out_Policy>; }
-struct TArgs_jsonpath_recv_Policy {
+TExecFunc arrow_md5_text() { return TGenericExec<TPgDirectFunc<&md5_text>, true, false, TArgs_md5_text_Policy>({}); }
+struct TArgs_mul_d_interval_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+};
+TExecFunc arrow_mul_d_interval() { return TGenericExec<TPgDirectFunc<&mul_d_interval>, true, false, TArgs_mul_d_interval_Policy>({}); }
+struct TArgs_nlikejoinsel_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+};
+TExecFunc arrow_nlikejoinsel() { return TGenericExec<TPgDirectFunc<&nlikejoinsel>, true, true, TArgs_nlikejoinsel_Policy>({}); }
+struct TArgs_nlikesel_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+};
+TExecFunc arrow_nlikesel() { return TGenericExec<TPgDirectFunc<&nlikesel>, true, true, TArgs_nlikesel_Policy>({}); }
+struct TArgs_now_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 0> IsFixedArg = {};
+};
+TExecFunc arrow_now() { return TGenericExec<TPgDirectFunc<&now>, true, true, TArgs_now_Policy>({}); }
+struct TArgs_numeric_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_jsonpath_recv() { return &GenericExec<TPgDirectFunc<&jsonpath_recv>, true, false, TArgs_jsonpath_recv_Policy>; }
-struct TArgs_jsonpath_send_Policy {
+TExecFunc arrow_numeric() { return TGenericExec<TPgDirectFunc<&numeric>, true, false, TArgs_numeric_Policy>({}); }
+struct TArgs_numeric_abs_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_jsonpath_send() { return &GenericExec<TPgDirectFunc<&jsonpath_send>, true, false, TArgs_jsonpath_send_Policy>; }
-struct TArgs_multirange_adjacent_multirange_Policy {
+TExecFunc arrow_numeric_abs() { return TGenericExec<TPgDirectFunc<&numeric_abs>, true, false, TArgs_numeric_abs_Policy>({}); }
+struct TArgs_numeric_accum_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_multirange_adjacent_multirange() { return &GenericExec<TPgDirectFunc<&multirange_adjacent_multirange>, true, true, TArgs_multirange_adjacent_multirange_Policy>; }
-struct TArgs_multirange_adjacent_range_Policy {
+TExecFunc arrow_numeric_accum() { return TGenericExec<TPgDirectFunc<&numeric_accum>, false, true, TArgs_numeric_accum_Policy>({}); }
+struct TArgs_numeric_accum_inv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_multirange_adjacent_range() { return &GenericExec<TPgDirectFunc<&multirange_adjacent_range>, true, true, TArgs_multirange_adjacent_range_Policy>; }
-struct TArgs_multirange_after_multirange_Policy {
+TExecFunc arrow_numeric_accum_inv() { return TGenericExec<TPgDirectFunc<&numeric_accum_inv>, false, true, TArgs_numeric_accum_inv_Policy>({}); }
+struct TArgs_numeric_add_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_multirange_after_multirange() { return &GenericExec<TPgDirectFunc<&multirange_after_multirange>, true, true, TArgs_multirange_after_multirange_Policy>; }
-struct TArgs_multirange_after_range_Policy {
+TExecFunc arrow_numeric_add() { return TGenericExec<TPgDirectFunc<&numeric_add>, true, false, TArgs_numeric_add_Policy>({}); }
+struct TArgs_numeric_avg_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_multirange_after_range() { return &GenericExec<TPgDirectFunc<&multirange_after_range>, true, true, TArgs_multirange_after_range_Policy>; }
-struct TArgs_multirange_before_multirange_Policy {
+TExecFunc arrow_numeric_avg() { return TGenericExec<TPgDirectFunc<&numeric_avg>, false, false, TArgs_numeric_avg_Policy>({}); }
+struct TArgs_numeric_avg_accum_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_multirange_before_multirange() { return &GenericExec<TPgDirectFunc<&multirange_before_multirange>, true, true, TArgs_multirange_before_multirange_Policy>; }
-struct TArgs_multirange_before_range_Policy {
+TExecFunc arrow_numeric_avg_accum() { return TGenericExec<TPgDirectFunc<&numeric_avg_accum>, false, true, TArgs_numeric_avg_accum_Policy>({}); }
+struct TArgs_numeric_avg_combine_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_multirange_before_range() { return &GenericExec<TPgDirectFunc<&multirange_before_range>, true, true, TArgs_multirange_before_range_Policy>; }
-struct TArgs_multirange_cmp_Policy {
+TExecFunc arrow_numeric_avg_combine() { return TGenericExec<TPgDirectFunc<&numeric_avg_combine>, false, true, TArgs_numeric_avg_combine_Policy>({}); }
+struct TArgs_numeric_avg_deserialize_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_multirange_cmp() { return &GenericExec<TPgDirectFunc<&multirange_cmp>, true, true, TArgs_multirange_cmp_Policy>; }
-struct TArgs_multirange_constructor0_Policy {
+TExecFunc arrow_numeric_avg_deserialize() { return TGenericExec<TPgDirectFunc<&numeric_avg_deserialize>, true, true, TArgs_numeric_avg_deserialize_Policy>({}); }
+struct TArgs_numeric_avg_serialize_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_multirange_constructor0() { return &GenericExec<TPgDirectFunc<&multirange_constructor0>, true, false, TArgs_multirange_constructor0_Policy>; }
-struct TArgs_multirange_constructor1_Policy {
+TExecFunc arrow_numeric_avg_serialize() { return TGenericExec<TPgDirectFunc<&numeric_avg_serialize>, true, false, TArgs_numeric_avg_serialize_Policy>({}); }
+struct TArgs_numeric_cash_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_multirange_constructor1() { return &GenericExec<TPgDirectFunc<&multirange_constructor1>, true, false, TArgs_multirange_constructor1_Policy>; }
-struct TArgs_multirange_contained_by_multirange_Policy {
+TExecFunc arrow_numeric_cash() { return TGenericExec<TPgDirectFunc<&numeric_cash>, true, true, TArgs_numeric_cash_Policy>({}); }
+struct TArgs_numeric_ceil_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_multirange_contained_by_multirange() { return &GenericExec<TPgDirectFunc<&multirange_contained_by_multirange>, true, true, TArgs_multirange_contained_by_multirange_Policy>; }
-struct TArgs_multirange_contained_by_range_Policy {
+TExecFunc arrow_numeric_ceil() { return TGenericExec<TPgDirectFunc<&numeric_ceil>, true, false, TArgs_numeric_ceil_Policy>({}); }
+struct TArgs_numeric_cmp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_multirange_contained_by_range() { return &GenericExec<TPgDirectFunc<&multirange_contained_by_range>, true, true, TArgs_multirange_contained_by_range_Policy>; }
-struct TArgs_multirange_contains_elem_Policy {
+TExecFunc arrow_numeric_cmp() { return TGenericExec<TPgDirectFunc<&numeric_cmp>, true, true, TArgs_numeric_cmp_Policy>({}); }
+struct TArgs_numeric_combine_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+};
+TExecFunc arrow_numeric_combine() { return TGenericExec<TPgDirectFunc<&numeric_combine>, false, true, TArgs_numeric_combine_Policy>({}); }
+struct TArgs_numeric_deserialize_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_multirange_contains_elem() { return &GenericExec<TPgDirectFunc<&multirange_contains_elem>, true, true, TArgs_multirange_contains_elem_Policy>; }
-struct TArgs_multirange_contains_multirange_Policy {
+TExecFunc arrow_numeric_deserialize() { return TGenericExec<TPgDirectFunc<&numeric_deserialize>, true, true, TArgs_numeric_deserialize_Policy>({}); }
+struct TArgs_numeric_div_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_multirange_contains_multirange() { return &GenericExec<TPgDirectFunc<&multirange_contains_multirange>, true, true, TArgs_multirange_contains_multirange_Policy>; }
-struct TArgs_multirange_contains_range_Policy {
+TExecFunc arrow_numeric_div() { return TGenericExec<TPgDirectFunc<&numeric_div>, true, false, TArgs_numeric_div_Policy>({}); }
+struct TArgs_numeric_div_trunc_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_multirange_contains_range() { return &GenericExec<TPgDirectFunc<&multirange_contains_range>, true, true, TArgs_multirange_contains_range_Policy>; }
-struct TArgs_multirange_empty_Policy {
+TExecFunc arrow_numeric_div_trunc() { return TGenericExec<TPgDirectFunc<&numeric_div_trunc>, true, false, TArgs_numeric_div_trunc_Policy>({}); }
+struct TArgs_numeric_eq_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_numeric_eq() { return TGenericExec<TPgDirectFunc<&numeric_eq>, true, true, TArgs_numeric_eq_Policy>({}); }
+struct TArgs_numeric_exp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_multirange_empty() { return &GenericExec<TPgDirectFunc<&multirange_empty>, true, true, TArgs_multirange_empty_Policy>; }
-struct TArgs_multirange_eq_Policy {
+TExecFunc arrow_numeric_exp() { return TGenericExec<TPgDirectFunc<&numeric_exp>, true, false, TArgs_numeric_exp_Policy>({}); }
+struct TArgs_numeric_fac_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_multirange_eq() { return &GenericExec<TPgDirectFunc<&multirange_eq>, true, true, TArgs_multirange_eq_Policy>; }
-struct TArgs_multirange_ge_Policy {
+TExecFunc arrow_numeric_fac() { return TGenericExec<TPgDirectFunc<&numeric_fac>, true, false, TArgs_numeric_fac_Policy>({}); }
+struct TArgs_numeric_float4_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_multirange_ge() { return &GenericExec<TPgDirectFunc<&multirange_ge>, true, true, TArgs_multirange_ge_Policy>; }
-struct TArgs_multirange_gt_Policy {
+TExecFunc arrow_numeric_float4() { return TGenericExec<TPgDirectFunc<&numeric_float4>, true, true, TArgs_numeric_float4_Policy>({}); }
+struct TArgs_numeric_float8_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_multirange_gt() { return &GenericExec<TPgDirectFunc<&multirange_gt>, true, true, TArgs_multirange_gt_Policy>; }
-struct TArgs_multirange_in_Policy {
+TExecFunc arrow_numeric_float8() { return TGenericExec<TPgDirectFunc<&numeric_float8>, true, true, TArgs_numeric_float8_Policy>({}); }
+struct TArgs_numeric_floor_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_multirange_in() { return &GenericExec<TPgDirectFunc<&multirange_in>, true, false, TArgs_multirange_in_Policy>; }
-struct TArgs_multirange_intersect_Policy {
+TExecFunc arrow_numeric_floor() { return TGenericExec<TPgDirectFunc<&numeric_floor>, true, false, TArgs_numeric_floor_Policy>({}); }
+struct TArgs_numeric_gcd_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_multirange_intersect() { return &GenericExec<TPgDirectFunc<&multirange_intersect>, true, false, TArgs_multirange_intersect_Policy>; }
-struct TArgs_multirange_intersect_agg_transfn_Policy {
+TExecFunc arrow_numeric_gcd() { return TGenericExec<TPgDirectFunc<&numeric_gcd>, true, false, TArgs_numeric_gcd_Policy>({}); }
+struct TArgs_numeric_ge_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_multirange_intersect_agg_transfn() { return &GenericExec<TPgDirectFunc<&multirange_intersect_agg_transfn>, true, false, TArgs_multirange_intersect_agg_transfn_Policy>; }
-struct TArgs_multirange_le_Policy {
+TExecFunc arrow_numeric_ge() { return TGenericExec<TPgDirectFunc<&numeric_ge>, true, true, TArgs_numeric_ge_Policy>({}); }
+struct TArgs_numeric_gt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_multirange_le() { return &GenericExec<TPgDirectFunc<&multirange_le>, true, true, TArgs_multirange_le_Policy>; }
-struct TArgs_multirange_lower_Policy {
+TExecFunc arrow_numeric_gt() { return TGenericExec<TPgDirectFunc<&numeric_gt>, true, true, TArgs_numeric_gt_Policy>({}); }
+struct TArgs_numeric_in_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+};
+TExecFunc arrow_numeric_in() { return TGenericExec<TPgDirectFunc<&numeric_in>, true, false, TArgs_numeric_in_Policy>({}); }
+struct TArgs_numeric_inc_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_multirange_lower() { return &GenericExec<TPgDirectFunc<&multirange_lower>, true, true, TArgs_multirange_lower_Policy>; }
-struct TArgs_multirange_lower_inc_Policy {
+TExecFunc arrow_numeric_inc() { return TGenericExec<TPgDirectFunc<&numeric_inc>, true, false, TArgs_numeric_inc_Policy>({}); }
+struct TArgs_numeric_int2_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_multirange_lower_inc() { return &GenericExec<TPgDirectFunc<&multirange_lower_inc>, true, true, TArgs_multirange_lower_inc_Policy>; }
-struct TArgs_multirange_lower_inf_Policy {
+TExecFunc arrow_numeric_int2() { return TGenericExec<TPgDirectFunc<&numeric_int2>, true, true, TArgs_numeric_int2_Policy>({}); }
+struct TArgs_numeric_int4_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_multirange_lower_inf() { return &GenericExec<TPgDirectFunc<&multirange_lower_inf>, true, true, TArgs_multirange_lower_inf_Policy>; }
-struct TArgs_multirange_lt_Policy {
+TExecFunc arrow_numeric_int4() { return TGenericExec<TPgDirectFunc<&numeric_int4>, true, true, TArgs_numeric_int4_Policy>({}); }
+struct TArgs_numeric_int8_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_numeric_int8() { return TGenericExec<TPgDirectFunc<&numeric_int8>, true, true, TArgs_numeric_int8_Policy>({}); }
+struct TArgs_numeric_larger_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_multirange_lt() { return &GenericExec<TPgDirectFunc<&multirange_lt>, true, true, TArgs_multirange_lt_Policy>; }
-struct TArgs_multirange_minus_Policy {
+TExecFunc arrow_numeric_larger() { return TGenericExec<TPgDirectFunc<&numeric_larger>, true, false, TArgs_numeric_larger_Policy>({}); }
+struct TArgs_numeric_lcm_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_multirange_minus() { return &GenericExec<TPgDirectFunc<&multirange_minus>, true, false, TArgs_multirange_minus_Policy>; }
-struct TArgs_multirange_ne_Policy {
+TExecFunc arrow_numeric_lcm() { return TGenericExec<TPgDirectFunc<&numeric_lcm>, true, false, TArgs_numeric_lcm_Policy>({}); }
+struct TArgs_numeric_le_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_multirange_ne() { return &GenericExec<TPgDirectFunc<&multirange_ne>, true, true, TArgs_multirange_ne_Policy>; }
-struct TArgs_multirange_out_Policy {
+TExecFunc arrow_numeric_le() { return TGenericExec<TPgDirectFunc<&numeric_le>, true, true, TArgs_numeric_le_Policy>({}); }
+struct TArgs_numeric_ln_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_multirange_out() { return &GenericExec<TPgDirectFunc<&multirange_out>, true, false, TArgs_multirange_out_Policy>; }
-struct TArgs_multirange_overlaps_multirange_Policy {
+TExecFunc arrow_numeric_ln() { return TGenericExec<TPgDirectFunc<&numeric_ln>, true, false, TArgs_numeric_ln_Policy>({}); }
+struct TArgs_numeric_log_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_multirange_overlaps_multirange() { return &GenericExec<TPgDirectFunc<&multirange_overlaps_multirange>, true, true, TArgs_multirange_overlaps_multirange_Policy>; }
-struct TArgs_multirange_overlaps_range_Policy {
+TExecFunc arrow_numeric_log() { return TGenericExec<TPgDirectFunc<&numeric_log>, true, false, TArgs_numeric_log_Policy>({}); }
+struct TArgs_numeric_lt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_multirange_overlaps_range() { return &GenericExec<TPgDirectFunc<&multirange_overlaps_range>, true, true, TArgs_multirange_overlaps_range_Policy>; }
-struct TArgs_multirange_overleft_multirange_Policy {
+TExecFunc arrow_numeric_lt() { return TGenericExec<TPgDirectFunc<&numeric_lt>, true, true, TArgs_numeric_lt_Policy>({}); }
+struct TArgs_numeric_min_scale_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_multirange_overleft_multirange() { return &GenericExec<TPgDirectFunc<&multirange_overleft_multirange>, true, true, TArgs_multirange_overleft_multirange_Policy>; }
-struct TArgs_multirange_overleft_range_Policy {
+TExecFunc arrow_numeric_min_scale() { return TGenericExec<TPgDirectFunc<&numeric_min_scale>, true, true, TArgs_numeric_min_scale_Policy>({}); }
+struct TArgs_numeric_mod_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_multirange_overleft_range() { return &GenericExec<TPgDirectFunc<&multirange_overleft_range>, true, true, TArgs_multirange_overleft_range_Policy>; }
-struct TArgs_multirange_overright_multirange_Policy {
+TExecFunc arrow_numeric_mod() { return TGenericExec<TPgDirectFunc<&numeric_mod>, true, false, TArgs_numeric_mod_Policy>({}); }
+struct TArgs_numeric_mul_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_multirange_overright_multirange() { return &GenericExec<TPgDirectFunc<&multirange_overright_multirange>, true, true, TArgs_multirange_overright_multirange_Policy>; }
-struct TArgs_multirange_overright_range_Policy {
+TExecFunc arrow_numeric_mul() { return TGenericExec<TPgDirectFunc<&numeric_mul>, true, false, TArgs_numeric_mul_Policy>({}); }
+struct TArgs_numeric_ne_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_multirange_overright_range() { return &GenericExec<TPgDirectFunc<&multirange_overright_range>, true, true, TArgs_multirange_overright_range_Policy>; }
-struct TArgs_multirange_recv_Policy {
+TExecFunc arrow_numeric_ne() { return TGenericExec<TPgDirectFunc<&numeric_ne>, true, true, TArgs_numeric_ne_Policy>({}); }
+struct TArgs_numeric_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_multirange_recv() { return &GenericExec<TPgDirectFunc<&multirange_recv>, true, false, TArgs_multirange_recv_Policy>; }
-struct TArgs_multirange_send_Policy {
+TExecFunc arrow_numeric_out() { return TGenericExec<TPgDirectFunc<&numeric_out>, true, false, TArgs_numeric_out_Policy>({}); }
+struct TArgs_numeric_pg_lsn_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_multirange_send() { return &GenericExec<TPgDirectFunc<&multirange_send>, true, false, TArgs_multirange_send_Policy>; }
-struct TArgs_multirange_union_Policy {
+TExecFunc arrow_numeric_pg_lsn() { return TGenericExec<TPgDirectFunc<&numeric_pg_lsn>, true, true, TArgs_numeric_pg_lsn_Policy>({}); }
+struct TArgs_numeric_poly_avg_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_numeric_poly_avg() { return TGenericExec<TPgDirectFunc<&numeric_poly_avg>, false, false, TArgs_numeric_poly_avg_Policy>({}); }
+struct TArgs_numeric_poly_combine_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+};
+TExecFunc arrow_numeric_poly_combine() { return TGenericExec<TPgDirectFunc<&numeric_poly_combine>, false, true, TArgs_numeric_poly_combine_Policy>({}); }
+struct TArgs_numeric_poly_deserialize_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+};
+TExecFunc arrow_numeric_poly_deserialize() { return TGenericExec<TPgDirectFunc<&numeric_poly_deserialize>, true, true, TArgs_numeric_poly_deserialize_Policy>({}); }
+struct TArgs_numeric_poly_serialize_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_numeric_poly_serialize() { return TGenericExec<TPgDirectFunc<&numeric_poly_serialize>, true, false, TArgs_numeric_poly_serialize_Policy>({}); }
+struct TArgs_numeric_poly_stddev_pop_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_numeric_poly_stddev_pop() { return TGenericExec<TPgDirectFunc<&numeric_poly_stddev_pop>, false, false, TArgs_numeric_poly_stddev_pop_Policy>({}); }
+struct TArgs_numeric_poly_stddev_samp_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_numeric_poly_stddev_samp() { return TGenericExec<TPgDirectFunc<&numeric_poly_stddev_samp>, false, false, TArgs_numeric_poly_stddev_samp_Policy>({}); }
+struct TArgs_numeric_poly_sum_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_numeric_poly_sum() { return TGenericExec<TPgDirectFunc<&numeric_poly_sum>, false, false, TArgs_numeric_poly_sum_Policy>({}); }
+struct TArgs_numeric_poly_var_pop_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_numeric_poly_var_pop() { return TGenericExec<TPgDirectFunc<&numeric_poly_var_pop>, false, false, TArgs_numeric_poly_var_pop_Policy>({}); }
+struct TArgs_numeric_poly_var_samp_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_numeric_poly_var_samp() { return TGenericExec<TPgDirectFunc<&numeric_poly_var_samp>, false, false, TArgs_numeric_poly_var_samp_Policy>({}); }
+struct TArgs_numeric_power_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_multirange_union() { return &GenericExec<TPgDirectFunc<&multirange_union>, true, false, TArgs_multirange_union_Policy>; }
-struct TArgs_multirange_upper_Policy {
+TExecFunc arrow_numeric_power() { return TGenericExec<TPgDirectFunc<&numeric_power>, true, false, TArgs_numeric_power_Policy>({}); }
+struct TArgs_numeric_recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_multirange_upper() { return &GenericExec<TPgDirectFunc<&multirange_upper>, true, true, TArgs_multirange_upper_Policy>; }
-struct TArgs_multirange_upper_inc_Policy {
+TExecFunc arrow_numeric_recv() { return TGenericExec<TPgDirectFunc<&numeric_recv>, true, false, TArgs_numeric_recv_Policy>({}); }
+struct TArgs_numeric_round_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+};
+TExecFunc arrow_numeric_round() { return TGenericExec<TPgDirectFunc<&numeric_round>, true, false, TArgs_numeric_round_Policy>({}); }
+struct TArgs_numeric_scale_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_multirange_upper_inc() { return &GenericExec<TPgDirectFunc<&multirange_upper_inc>, true, true, TArgs_multirange_upper_inc_Policy>; }
-struct TArgs_multirange_upper_inf_Policy {
+TExecFunc arrow_numeric_scale() { return TGenericExec<TPgDirectFunc<&numeric_scale>, true, true, TArgs_numeric_scale_Policy>({}); }
+struct TArgs_numeric_send_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_multirange_upper_inf() { return &GenericExec<TPgDirectFunc<&multirange_upper_inf>, true, true, TArgs_multirange_upper_inf_Policy>; }
-struct TArgs_name_text_Policy {
+TExecFunc arrow_numeric_send() { return TGenericExec<TPgDirectFunc<&numeric_send>, true, false, TArgs_numeric_send_Policy>({}); }
+struct TArgs_numeric_serialize_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_numeric_serialize() { return TGenericExec<TPgDirectFunc<&numeric_serialize>, true, false, TArgs_numeric_serialize_Policy>({}); }
+struct TArgs_numeric_sign_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_name_text() { return &GenericExec<TPgDirectFunc<&name_text>, true, false, TArgs_name_text_Policy>; }
-struct TArgs_nameeqtext_Policy {
+TExecFunc arrow_numeric_sign() { return TGenericExec<TPgDirectFunc<&numeric_sign>, true, false, TArgs_numeric_sign_Policy>({}); }
+struct TArgs_numeric_smaller_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_nameeqtext() { return &GenericExec<TPgDirectFunc<&nameeqtext>, true, true, TArgs_nameeqtext_Policy>; }
-struct TArgs_namegetext_Policy {
+TExecFunc arrow_numeric_smaller() { return TGenericExec<TPgDirectFunc<&numeric_smaller>, true, false, TArgs_numeric_smaller_Policy>({}); }
+struct TArgs_numeric_sortsupport_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_namegetext() { return &GenericExec<TPgDirectFunc<&namegetext>, true, true, TArgs_namegetext_Policy>; }
-struct TArgs_namegttext_Policy {
+TExecFunc arrow_numeric_sortsupport() { return TGenericExec<TPgDirectFunc<&numeric_sortsupport>, true, true, TArgs_numeric_sortsupport_Policy>({}); }
+struct TArgs_numeric_sqrt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_namegttext() { return &GenericExec<TPgDirectFunc<&namegttext>, true, true, TArgs_namegttext_Policy>; }
-struct TArgs_nameicregexeq_Policy {
+TExecFunc arrow_numeric_sqrt() { return TGenericExec<TPgDirectFunc<&numeric_sqrt>, true, false, TArgs_numeric_sqrt_Policy>({}); }
+struct TArgs_numeric_stddev_pop_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_nameicregexeq() { return &GenericExec<TPgDirectFunc<&nameicregexeq>, true, true, TArgs_nameicregexeq_Policy>; }
-struct TArgs_nameicregexne_Policy {
+TExecFunc arrow_numeric_stddev_pop() { return TGenericExec<TPgDirectFunc<&numeric_stddev_pop>, false, false, TArgs_numeric_stddev_pop_Policy>({}); }
+struct TArgs_numeric_stddev_samp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_nameicregexne() { return &GenericExec<TPgDirectFunc<&nameicregexne>, true, true, TArgs_nameicregexne_Policy>; }
-struct TArgs_nameletext_Policy {
+TExecFunc arrow_numeric_stddev_samp() { return TGenericExec<TPgDirectFunc<&numeric_stddev_samp>, false, false, TArgs_numeric_stddev_samp_Policy>({}); }
+struct TArgs_numeric_sub_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_nameletext() { return &GenericExec<TPgDirectFunc<&nameletext>, true, true, TArgs_nameletext_Policy>; }
-struct TArgs_namelttext_Policy {
+TExecFunc arrow_numeric_sub() { return TGenericExec<TPgDirectFunc<&numeric_sub>, true, false, TArgs_numeric_sub_Policy>({}); }
+struct TArgs_numeric_sum_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_namelttext() { return &GenericExec<TPgDirectFunc<&namelttext>, true, true, TArgs_namelttext_Policy>; }
-struct TArgs_namenetext_Policy {
+TExecFunc arrow_numeric_sum() { return TGenericExec<TPgDirectFunc<&numeric_sum>, false, false, TArgs_numeric_sum_Policy>({}); }
+struct TArgs_numeric_support_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_namenetext() { return &GenericExec<TPgDirectFunc<&namenetext>, true, true, TArgs_namenetext_Policy>; }
-struct TArgs_nameregexeq_Policy {
+TExecFunc arrow_numeric_support() { return TGenericExec<TPgDirectFunc<&numeric_support>, true, true, TArgs_numeric_support_Policy>({}); }
+struct TArgs_numeric_to_char_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_nameregexeq() { return &GenericExec<TPgDirectFunc<&nameregexeq>, true, true, TArgs_nameregexeq_Policy>; }
-struct TArgs_nameregexne_Policy {
+TExecFunc arrow_numeric_to_char() { return TGenericExec<TPgDirectFunc<&numeric_to_char>, true, false, TArgs_numeric_to_char_Policy>({}); }
+struct TArgs_numeric_to_number_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_nameregexne() { return &GenericExec<TPgDirectFunc<&nameregexne>, true, true, TArgs_nameregexne_Policy>; }
-struct TArgs_numeric_cash_Policy {
+TExecFunc arrow_numeric_to_number() { return TGenericExec<TPgDirectFunc<&numeric_to_number>, true, false, TArgs_numeric_to_number_Policy>({}); }
+struct TArgs_numeric_trim_scale_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_numeric_cash() { return &GenericExec<TPgDirectFunc<&numeric_cash>, true, true, TArgs_numeric_cash_Policy>; }
-struct TArgs_oideq_Policy {
+TExecFunc arrow_numeric_trim_scale() { return TGenericExec<TPgDirectFunc<&numeric_trim_scale>, true, false, TArgs_numeric_trim_scale_Policy>({}); }
+struct TArgs_numeric_trunc_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_oideq() { return &GenericExec<TPgDirectFunc<&oideq>, true, true, TArgs_oideq_Policy>; }
-struct TArgs_oidge_Policy {
+TExecFunc arrow_numeric_trunc() { return TGenericExec<TPgDirectFunc<&numeric_trunc>, true, false, TArgs_numeric_trunc_Policy>({}); }
+struct TArgs_numeric_uminus_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_oidge() { return &GenericExec<TPgDirectFunc<&oidge>, true, true, TArgs_oidge_Policy>; }
-struct TArgs_oidgt_Policy {
+TExecFunc arrow_numeric_uminus() { return TGenericExec<TPgDirectFunc<&numeric_uminus>, true, false, TArgs_numeric_uminus_Policy>({}); }
+struct TArgs_numeric_uplus_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_oidgt() { return &GenericExec<TPgDirectFunc<&oidgt>, true, true, TArgs_oidgt_Policy>; }
-struct TArgs_oidin_Policy {
+TExecFunc arrow_numeric_uplus() { return TGenericExec<TPgDirectFunc<&numeric_uplus>, true, false, TArgs_numeric_uplus_Policy>({}); }
+struct TArgs_numeric_var_pop_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_oidin() { return &GenericExec<TPgDirectFunc<&oidin>, true, true, TArgs_oidin_Policy>; }
-struct TArgs_oidlarger_Policy {
+TExecFunc arrow_numeric_var_pop() { return TGenericExec<TPgDirectFunc<&numeric_var_pop>, false, false, TArgs_numeric_var_pop_Policy>({}); }
+struct TArgs_numeric_var_samp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_oidlarger() { return &GenericExec<TPgDirectFunc<&oidlarger>, true, true, TArgs_oidlarger_Policy>; }
-struct TArgs_oidle_Policy {
+TExecFunc arrow_numeric_var_samp() { return TGenericExec<TPgDirectFunc<&numeric_var_samp>, false, false, TArgs_numeric_var_samp_Policy>({}); }
+struct TArgs_numerictypmodin_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_oidle() { return &GenericExec<TPgDirectFunc<&oidle>, true, true, TArgs_oidle_Policy>; }
-struct TArgs_oidlt_Policy {
+TExecFunc arrow_numerictypmodin() { return TGenericExec<TPgDirectFunc<&numerictypmodin>, true, true, TArgs_numerictypmodin_Policy>({}); }
+struct TArgs_numerictypmodout_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_oidlt() { return &GenericExec<TPgDirectFunc<&oidlt>, true, true, TArgs_oidlt_Policy>; }
-struct TArgs_oidne_Policy {
+TExecFunc arrow_numerictypmodout() { return TGenericExec<TPgDirectFunc<&numerictypmodout>, true, false, TArgs_numerictypmodout_Policy>({}); }
+struct TArgs_on_pb_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_oidne() { return &GenericExec<TPgDirectFunc<&oidne>, true, true, TArgs_oidne_Policy>; }
-struct TArgs_oidout_Policy {
+TExecFunc arrow_on_pb() { return TGenericExec<TPgDirectFunc<&on_pb>, true, true, TArgs_on_pb_Policy>({}); }
+struct TArgs_on_pl_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_oidout() { return &GenericExec<TPgDirectFunc<&oidout>, true, false, TArgs_oidout_Policy>; }
-struct TArgs_oidrecv_Policy {
+TExecFunc arrow_on_pl() { return TGenericExec<TPgDirectFunc<&on_pl>, true, true, TArgs_on_pl_Policy>({}); }
+struct TArgs_on_ppath_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_oidrecv() { return &GenericExec<TPgDirectFunc<&oidrecv>, true, true, TArgs_oidrecv_Policy>; }
-struct TArgs_oidsend_Policy {
+TExecFunc arrow_on_ppath() { return TGenericExec<TPgDirectFunc<&on_ppath>, true, true, TArgs_on_ppath_Policy>({}); }
+struct TArgs_on_ps_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_oidsend() { return &GenericExec<TPgDirectFunc<&oidsend>, true, false, TArgs_oidsend_Policy>; }
-struct TArgs_oidsmaller_Policy {
+TExecFunc arrow_on_ps() { return TGenericExec<TPgDirectFunc<&on_ps>, true, true, TArgs_on_ps_Policy>({}); }
+struct TArgs_on_sb_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_oidsmaller() { return &GenericExec<TPgDirectFunc<&oidsmaller>, true, true, TArgs_oidsmaller_Policy>; }
-struct TArgs_oidvectoreq_Policy {
+TExecFunc arrow_on_sb() { return TGenericExec<TPgDirectFunc<&on_sb>, true, true, TArgs_on_sb_Policy>({}); }
+struct TArgs_on_sl_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_oidvectoreq() { return &GenericExec<TPgDirectFunc<&oidvectoreq>, true, true, TArgs_oidvectoreq_Policy>; }
-struct TArgs_oidvectorge_Policy {
+TExecFunc arrow_on_sl() { return TGenericExec<TPgDirectFunc<&on_sl>, true, true, TArgs_on_sl_Policy>({}); }
+struct TArgs_overlaps_timestamp_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+};
+TExecFunc arrow_overlaps_timestamp() { return TGenericExec<TPgDirectFunc<&overlaps_timestamp>, false, true, TArgs_overlaps_timestamp_Policy>({}); }
+struct TArgs_parse_ident_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+};
+TExecFunc arrow_parse_ident() { return TGenericExec<TPgDirectFunc<&parse_ident>, true, false, TArgs_parse_ident_Policy>({}); }
+struct TArgs_path_add_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_oidvectorge() { return &GenericExec<TPgDirectFunc<&oidvectorge>, true, true, TArgs_oidvectorge_Policy>; }
-struct TArgs_oidvectorgt_Policy {
+TExecFunc arrow_path_add() { return TGenericExec<TPgDirectFunc<&path_add>, true, false, TArgs_path_add_Policy>({}); }
+struct TArgs_path_add_pt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_oidvectorgt() { return &GenericExec<TPgDirectFunc<&oidvectorgt>, true, true, TArgs_oidvectorgt_Policy>; }
-struct TArgs_oidvectorin_Policy {
+TExecFunc arrow_path_add_pt() { return TGenericExec<TPgDirectFunc<&path_add_pt>, true, false, TArgs_path_add_pt_Policy>({}); }
+struct TArgs_path_area_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_oidvectorin() { return &GenericExec<TPgDirectFunc<&oidvectorin>, true, false, TArgs_oidvectorin_Policy>; }
-struct TArgs_oidvectorle_Policy {
+TExecFunc arrow_path_area() { return TGenericExec<TPgDirectFunc<&path_area>, true, true, TArgs_path_area_Policy>({}); }
+struct TArgs_path_center_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_oidvectorle() { return &GenericExec<TPgDirectFunc<&oidvectorle>, true, true, TArgs_oidvectorle_Policy>; }
-struct TArgs_oidvectorlt_Policy {
+TExecFunc arrow_path_center() { return TGenericExec<TPgDirectFunc<&path_center>, true, false, TArgs_path_center_Policy>({}); }
+struct TArgs_path_close_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_path_close() { return TGenericExec<TPgDirectFunc<&path_close>, true, false, TArgs_path_close_Policy>({}); }
+struct TArgs_path_distance_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_oidvectorlt() { return &GenericExec<TPgDirectFunc<&oidvectorlt>, true, true, TArgs_oidvectorlt_Policy>; }
-struct TArgs_oidvectorne_Policy {
+TExecFunc arrow_path_distance() { return TGenericExec<TPgDirectFunc<&path_distance>, true, true, TArgs_path_distance_Policy>({}); }
+struct TArgs_path_div_pt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_oidvectorne() { return &GenericExec<TPgDirectFunc<&oidvectorne>, true, true, TArgs_oidvectorne_Policy>; }
-struct TArgs_oidvectorout_Policy {
+TExecFunc arrow_path_div_pt() { return TGenericExec<TPgDirectFunc<&path_div_pt>, true, false, TArgs_path_div_pt_Policy>({}); }
+struct TArgs_path_in_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_oidvectorout() { return &GenericExec<TPgDirectFunc<&oidvectorout>, true, false, TArgs_oidvectorout_Policy>; }
-struct TArgs_oidvectorrecv_Policy {
+TExecFunc arrow_path_in() { return TGenericExec<TPgDirectFunc<&path_in>, true, false, TArgs_path_in_Policy>({}); }
+struct TArgs_path_inter_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_oidvectorrecv() { return &GenericExec<TPgDirectFunc<&oidvectorrecv>, true, false, TArgs_oidvectorrecv_Policy>; }
-struct TArgs_oidvectorsend_Policy {
+TExecFunc arrow_path_inter() { return TGenericExec<TPgDirectFunc<&path_inter>, true, true, TArgs_path_inter_Policy>({}); }
+struct TArgs_path_isclosed_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_oidvectorsend() { return &GenericExec<TPgDirectFunc<&oidvectorsend>, true, false, TArgs_oidvectorsend_Policy>; }
-struct TArgs_oidvectortypes_Policy {
+TExecFunc arrow_path_isclosed() { return TGenericExec<TPgDirectFunc<&path_isclosed>, true, true, TArgs_path_isclosed_Policy>({}); }
+struct TArgs_path_isopen_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_oidvectortypes() { return &GenericExec<TPgDirectFunc<&oidvectortypes>, true, false, TArgs_oidvectortypes_Policy>; }
-struct TArgs_pg_advisory_lock_int4_Policy {
+TExecFunc arrow_path_isopen() { return TGenericExec<TPgDirectFunc<&path_isopen>, true, true, TArgs_path_isopen_Policy>({}); }
+struct TArgs_path_length_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_advisory_lock_int4() { return &GenericExec<TPgDirectFunc<&pg_advisory_lock_int4>, true, true, TArgs_pg_advisory_lock_int4_Policy>; }
-struct TArgs_pg_advisory_lock_int8_Policy {
+TExecFunc arrow_path_length() { return TGenericExec<TPgDirectFunc<&path_length>, true, true, TArgs_path_length_Policy>({}); }
+struct TArgs_path_mul_pt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_advisory_lock_int8() { return &GenericExec<TPgDirectFunc<&pg_advisory_lock_int8>, true, true, TArgs_pg_advisory_lock_int8_Policy>; }
-struct TArgs_pg_advisory_lock_shared_int4_Policy {
+TExecFunc arrow_path_mul_pt() { return TGenericExec<TPgDirectFunc<&path_mul_pt>, true, false, TArgs_path_mul_pt_Policy>({}); }
+struct TArgs_path_n_eq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_advisory_lock_shared_int4() { return &GenericExec<TPgDirectFunc<&pg_advisory_lock_shared_int4>, true, true, TArgs_pg_advisory_lock_shared_int4_Policy>; }
-struct TArgs_pg_advisory_lock_shared_int8_Policy {
+TExecFunc arrow_path_n_eq() { return TGenericExec<TPgDirectFunc<&path_n_eq>, true, true, TArgs_path_n_eq_Policy>({}); }
+struct TArgs_path_n_ge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_advisory_lock_shared_int8() { return &GenericExec<TPgDirectFunc<&pg_advisory_lock_shared_int8>, true, true, TArgs_pg_advisory_lock_shared_int8_Policy>; }
-struct TArgs_pg_advisory_unlock_all_Policy {
+TExecFunc arrow_path_n_ge() { return TGenericExec<TPgDirectFunc<&path_n_ge>, true, true, TArgs_path_n_ge_Policy>({}); }
+struct TArgs_path_n_gt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_advisory_unlock_all() { return &GenericExec<TPgDirectFunc<&pg_advisory_unlock_all>, true, true, TArgs_pg_advisory_unlock_all_Policy>; }
-struct TArgs_pg_advisory_unlock_int4_Policy {
+TExecFunc arrow_path_n_gt() { return TGenericExec<TPgDirectFunc<&path_n_gt>, true, true, TArgs_path_n_gt_Policy>({}); }
+struct TArgs_path_n_le_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_advisory_unlock_int4() { return &GenericExec<TPgDirectFunc<&pg_advisory_unlock_int4>, true, true, TArgs_pg_advisory_unlock_int4_Policy>; }
-struct TArgs_pg_advisory_unlock_int8_Policy {
+TExecFunc arrow_path_n_le() { return TGenericExec<TPgDirectFunc<&path_n_le>, true, true, TArgs_path_n_le_Policy>({}); }
+struct TArgs_path_n_lt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_advisory_unlock_int8() { return &GenericExec<TPgDirectFunc<&pg_advisory_unlock_int8>, true, true, TArgs_pg_advisory_unlock_int8_Policy>; }
-struct TArgs_pg_advisory_unlock_shared_int4_Policy {
+TExecFunc arrow_path_n_lt() { return TGenericExec<TPgDirectFunc<&path_n_lt>, true, true, TArgs_path_n_lt_Policy>({}); }
+struct TArgs_path_npoints_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_advisory_unlock_shared_int4() { return &GenericExec<TPgDirectFunc<&pg_advisory_unlock_shared_int4>, true, true, TArgs_pg_advisory_unlock_shared_int4_Policy>; }
-struct TArgs_pg_advisory_unlock_shared_int8_Policy {
+TExecFunc arrow_path_npoints() { return TGenericExec<TPgDirectFunc<&path_npoints>, true, true, TArgs_path_npoints_Policy>({}); }
+struct TArgs_path_open_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_advisory_unlock_shared_int8() { return &GenericExec<TPgDirectFunc<&pg_advisory_unlock_shared_int8>, true, true, TArgs_pg_advisory_unlock_shared_int8_Policy>; }
-struct TArgs_pg_advisory_xact_lock_int4_Policy {
+TExecFunc arrow_path_open() { return TGenericExec<TPgDirectFunc<&path_open>, true, false, TArgs_path_open_Policy>({}); }
+struct TArgs_path_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_advisory_xact_lock_int4() { return &GenericExec<TPgDirectFunc<&pg_advisory_xact_lock_int4>, true, true, TArgs_pg_advisory_xact_lock_int4_Policy>; }
-struct TArgs_pg_advisory_xact_lock_int8_Policy {
+TExecFunc arrow_path_out() { return TGenericExec<TPgDirectFunc<&path_out>, true, false, TArgs_path_out_Policy>({}); }
+struct TArgs_path_poly_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_advisory_xact_lock_int8() { return &GenericExec<TPgDirectFunc<&pg_advisory_xact_lock_int8>, true, true, TArgs_pg_advisory_xact_lock_int8_Policy>; }
-struct TArgs_pg_advisory_xact_lock_shared_int4_Policy {
+TExecFunc arrow_path_poly() { return TGenericExec<TPgDirectFunc<&path_poly>, true, false, TArgs_path_poly_Policy>({}); }
+struct TArgs_path_recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_advisory_xact_lock_shared_int4() { return &GenericExec<TPgDirectFunc<&pg_advisory_xact_lock_shared_int4>, true, true, TArgs_pg_advisory_xact_lock_shared_int4_Policy>; }
-struct TArgs_pg_advisory_xact_lock_shared_int8_Policy {
+TExecFunc arrow_path_recv() { return TGenericExec<TPgDirectFunc<&path_recv>, true, false, TArgs_path_recv_Policy>({}); }
+struct TArgs_path_send_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_advisory_xact_lock_shared_int8() { return &GenericExec<TPgDirectFunc<&pg_advisory_xact_lock_shared_int8>, true, true, TArgs_pg_advisory_xact_lock_shared_int8_Policy>; }
-struct TArgs_pg_backup_start_time_Policy {
+TExecFunc arrow_path_send() { return TGenericExec<TPgDirectFunc<&path_send>, true, false, TArgs_path_send_Policy>({}); }
+struct TArgs_path_sub_pt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_backup_start_time() { return &GenericExec<TPgDirectFunc<&pg_backup_start_time>, true, true, TArgs_pg_backup_start_time_Policy>; }
-struct TArgs_pg_blocking_pids_Policy {
+TExecFunc arrow_path_sub_pt() { return TGenericExec<TPgDirectFunc<&path_sub_pt>, true, false, TArgs_path_sub_pt_Policy>({}); }
+struct TArgs_pg_collation_for_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_blocking_pids() { return &GenericExec<TPgDirectFunc<&pg_blocking_pids>, true, false, TArgs_pg_blocking_pids_Policy>; }
-struct TArgs_pg_collation_is_visible_Policy {
+TExecFunc arrow_pg_collation_for() { return TGenericExec<TPgDirectFunc<&pg_collation_for>, false, false, TArgs_pg_collation_for_Policy>({}); }
+struct TArgs_pg_column_is_updatable_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_pg_collation_is_visible() { return &GenericExec<TPgDirectFunc<&pg_collation_is_visible>, true, true, TArgs_pg_collation_is_visible_Policy>; }
-struct TArgs_pg_column_compression_Policy {
+TExecFunc arrow_pg_column_is_updatable() { return TGenericExec<TPgDirectFunc<&pg_column_is_updatable>, true, true, TArgs_pg_column_is_updatable_Policy>({}); }
+struct TArgs_pg_conf_load_time_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_pg_column_compression() { return &GenericExec<TPgDirectFunc<&pg_column_compression>, true, false, TArgs_pg_column_compression_Policy>; }
-struct TArgs_pg_column_size_Policy {
+TExecFunc arrow_pg_conf_load_time() { return TGenericExec<TPgDirectFunc<&pg_conf_load_time>, true, true, TArgs_pg_conf_load_time_Policy>({}); }
+struct TArgs_pg_copy_logical_replication_slot_a_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,false,true,false};
 };
-TExecFunc arrow_pg_column_size() { return &GenericExec<TPgDirectFunc<&pg_column_size>, true, true, TArgs_pg_column_size_Policy>; }
-struct TArgs_pg_control_checkpoint_Policy {
+TExecFunc arrow_pg_copy_logical_replication_slot_a() { return TGenericExec<TPgDirectFunc<&pg_copy_logical_replication_slot_a>, true, false, TArgs_pg_copy_logical_replication_slot_a_Policy>({}); }
+struct TArgs_pg_copy_logical_replication_slot_b_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,true};
 };
-TExecFunc arrow_pg_control_checkpoint() { return &GenericExec<TPgDirectFunc<&pg_control_checkpoint>, true, false, TArgs_pg_control_checkpoint_Policy>; }
-struct TArgs_pg_control_init_Policy {
+TExecFunc arrow_pg_copy_logical_replication_slot_b() { return TGenericExec<TPgDirectFunc<&pg_copy_logical_replication_slot_b>, true, false, TArgs_pg_copy_logical_replication_slot_b_Policy>({}); }
+struct TArgs_pg_copy_logical_replication_slot_c_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_control_init() { return &GenericExec<TPgDirectFunc<&pg_control_init>, true, false, TArgs_pg_control_init_Policy>; }
-struct TArgs_pg_control_recovery_Policy {
+TExecFunc arrow_pg_copy_logical_replication_slot_c() { return TGenericExec<TPgDirectFunc<&pg_copy_logical_replication_slot_c>, true, false, TArgs_pg_copy_logical_replication_slot_c_Policy>({}); }
+struct TArgs_pg_copy_physical_replication_slot_a_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,true};
 };
-TExecFunc arrow_pg_control_recovery() { return &GenericExec<TPgDirectFunc<&pg_control_recovery>, true, false, TArgs_pg_control_recovery_Policy>; }
-struct TArgs_pg_control_system_Policy {
+TExecFunc arrow_pg_copy_physical_replication_slot_a() { return TGenericExec<TPgDirectFunc<&pg_copy_physical_replication_slot_a>, true, false, TArgs_pg_copy_physical_replication_slot_a_Policy>({}); }
+struct TArgs_pg_copy_physical_replication_slot_b_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_control_system() { return &GenericExec<TPgDirectFunc<&pg_control_system>, true, false, TArgs_pg_control_system_Policy>; }
-struct TArgs_pg_conversion_is_visible_Policy {
+TExecFunc arrow_pg_copy_physical_replication_slot_b() { return TGenericExec<TPgDirectFunc<&pg_copy_physical_replication_slot_b>, true, false, TArgs_pg_copy_physical_replication_slot_b_Policy>({}); }
+struct TArgs_pg_create_logical_replication_slot_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,false,true,true};
 };
-TExecFunc arrow_pg_conversion_is_visible() { return &GenericExec<TPgDirectFunc<&pg_conversion_is_visible>, true, true, TArgs_pg_conversion_is_visible_Policy>; }
-struct TArgs_pg_create_restore_point_Policy {
+TExecFunc arrow_pg_create_logical_replication_slot() { return TGenericExec<TPgDirectFunc<&pg_create_logical_replication_slot>, true, false, TArgs_pg_create_logical_replication_slot_Policy>({}); }
+struct TArgs_pg_create_physical_replication_slot_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_pg_create_restore_point() { return &GenericExec<TPgDirectFunc<&pg_create_restore_point>, true, true, TArgs_pg_create_restore_point_Policy>; }
-struct TArgs_pg_current_wal_flush_lsn_Policy {
+TExecFunc arrow_pg_create_physical_replication_slot() { return TGenericExec<TPgDirectFunc<&pg_create_physical_replication_slot>, true, false, TArgs_pg_create_physical_replication_slot_Policy>({}); }
+struct TArgs_pg_current_logfile_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_pg_current_wal_flush_lsn() { return &GenericExec<TPgDirectFunc<&pg_current_wal_flush_lsn>, true, true, TArgs_pg_current_wal_flush_lsn_Policy>; }
-struct TArgs_pg_current_wal_insert_lsn_Policy {
+TExecFunc arrow_pg_current_logfile() { return TGenericExec<TPgDirectFunc<&pg_current_logfile>, false, false, TArgs_pg_current_logfile_Policy>({}); }
+struct TArgs_pg_current_logfile_1arg_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_current_wal_insert_lsn() { return &GenericExec<TPgDirectFunc<&pg_current_wal_insert_lsn>, true, true, TArgs_pg_current_wal_insert_lsn_Policy>; }
-struct TArgs_pg_current_wal_lsn_Policy {
+TExecFunc arrow_pg_current_logfile_1arg() { return TGenericExec<TPgDirectFunc<&pg_current_logfile_1arg>, false, false, TArgs_pg_current_logfile_1arg_Policy>({}); }
+struct TArgs_pg_current_snapshot_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_pg_current_wal_lsn() { return &GenericExec<TPgDirectFunc<&pg_current_wal_lsn>, true, true, TArgs_pg_current_wal_lsn_Policy>; }
-struct TArgs_pg_function_is_visible_Policy {
+TExecFunc arrow_pg_current_snapshot() { return TGenericExec<TPgDirectFunc<&pg_current_snapshot>, true, false, TArgs_pg_current_snapshot_Policy>({}); }
+struct TArgs_pg_current_xact_id_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_pg_function_is_visible() { return &GenericExec<TPgDirectFunc<&pg_function_is_visible>, true, true, TArgs_pg_function_is_visible_Policy>; }
-struct TArgs_pg_get_wal_replay_pause_state_Policy {
+TExecFunc arrow_pg_current_xact_id() { return TGenericExec<TPgDirectFunc<&pg_current_xact_id>, true, true, TArgs_pg_current_xact_id_Policy>({}); }
+struct TArgs_pg_current_xact_id_if_assigned_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_pg_get_wal_replay_pause_state() { return &GenericExec<TPgDirectFunc<&pg_get_wal_replay_pause_state>, true, false, TArgs_pg_get_wal_replay_pause_state_Policy>; }
-struct TArgs_pg_index_column_has_property_Policy {
+TExecFunc arrow_pg_current_xact_id_if_assigned() { return TGenericExec<TPgDirectFunc<&pg_current_xact_id_if_assigned>, true, true, TArgs_pg_current_xact_id_if_assigned_Policy>({}); }
+struct TArgs_pg_describe_object_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,true,false};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_pg_index_column_has_property() { return &GenericExec<TPgDirectFunc<&pg_index_column_has_property>, true, true, TArgs_pg_index_column_has_property_Policy>; }
-struct TArgs_pg_index_has_property_Policy {
+TExecFunc arrow_pg_describe_object() { return TGenericExec<TPgDirectFunc<&pg_describe_object>, true, false, TArgs_pg_describe_object_Policy>({}); }
+struct TArgs_pg_drop_replication_slot_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_index_has_property() { return &GenericExec<TPgDirectFunc<&pg_index_has_property>, true, true, TArgs_pg_index_has_property_Policy>; }
-struct TArgs_pg_indexam_has_property_Policy {
+TExecFunc arrow_pg_drop_replication_slot() { return TGenericExec<TPgDirectFunc<&pg_drop_replication_slot>, true, true, TArgs_pg_drop_replication_slot_Policy>({}); }
+struct TArgs_pg_get_object_address_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
 };
-TExecFunc arrow_pg_indexam_has_property() { return &GenericExec<TPgDirectFunc<&pg_indexam_has_property>, true, true, TArgs_pg_indexam_has_property_Policy>; }
-struct TArgs_pg_indexam_progress_phasename_Policy {
+TExecFunc arrow_pg_get_object_address() { return TGenericExec<TPgDirectFunc<&pg_get_object_address>, true, false, TArgs_pg_get_object_address_Policy>({}); }
+struct TArgs_pg_get_replica_identity_index_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_indexam_progress_phasename() { return &GenericExec<TPgDirectFunc<&pg_indexam_progress_phasename>, true, false, TArgs_pg_indexam_progress_phasename_Policy>; }
-struct TArgs_pg_is_in_backup_Policy {
+TExecFunc arrow_pg_get_replica_identity_index() { return TGenericExec<TPgDirectFunc<&pg_get_replica_identity_index>, true, true, TArgs_pg_get_replica_identity_index_Policy>({}); }
+struct TArgs_pg_identify_object_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_pg_is_in_backup() { return &GenericExec<TPgDirectFunc<&pg_is_in_backup>, true, true, TArgs_pg_is_in_backup_Policy>; }
-struct TArgs_pg_is_in_recovery_Policy {
+TExecFunc arrow_pg_identify_object() { return TGenericExec<TPgDirectFunc<&pg_identify_object>, true, false, TArgs_pg_identify_object_Policy>({}); }
+struct TArgs_pg_identify_object_as_address_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_pg_is_in_recovery() { return &GenericExec<TPgDirectFunc<&pg_is_in_recovery>, true, true, TArgs_pg_is_in_recovery_Policy>; }
-struct TArgs_pg_is_other_temp_schema_Policy {
+TExecFunc arrow_pg_identify_object_as_address() { return TGenericExec<TPgDirectFunc<&pg_identify_object_as_address>, true, false, TArgs_pg_identify_object_as_address_Policy>({}); }
+struct TArgs_pg_partition_root_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_is_other_temp_schema() { return &GenericExec<TPgDirectFunc<&pg_is_other_temp_schema>, true, true, TArgs_pg_is_other_temp_schema_Policy>; }
-struct TArgs_pg_is_wal_replay_paused_Policy {
+TExecFunc arrow_pg_partition_root() { return TGenericExec<TPgDirectFunc<&pg_partition_root>, true, true, TArgs_pg_partition_root_Policy>({}); }
+struct TArgs_pg_postmaster_start_time_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_pg_is_wal_replay_paused() { return &GenericExec<TPgDirectFunc<&pg_is_wal_replay_paused>, true, true, TArgs_pg_is_wal_replay_paused_Policy>; }
-struct TArgs_pg_isolation_test_session_is_blocked_Policy {
+TExecFunc arrow_pg_postmaster_start_time() { return TGenericExec<TPgDirectFunc<&pg_postmaster_start_time>, true, true, TArgs_pg_postmaster_start_time_Policy>({}); }
+struct TArgs_pg_read_binary_file_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,true,true,true};
 };
-TExecFunc arrow_pg_isolation_test_session_is_blocked() { return &GenericExec<TPgDirectFunc<&pg_isolation_test_session_is_blocked>, true, true, TArgs_pg_isolation_test_session_is_blocked_Policy>; }
-struct TArgs_pg_jit_available_Policy {
+TExecFunc arrow_pg_read_binary_file() { return TGenericExec<TPgDirectFunc<&pg_read_binary_file>, true, false, TArgs_pg_read_binary_file_Policy>({}); }
+struct TArgs_pg_read_binary_file_all_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
-};
-TExecFunc arrow_pg_jit_available() { return &GenericExec<TPgDirectFunc<&pg_jit_available>, true, true, TArgs_pg_jit_available_Policy>; }
-struct TArgs_pg_last_committed_xact_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_last_committed_xact() { return &GenericExec<TPgDirectFunc<&pg_last_committed_xact>, true, false, TArgs_pg_last_committed_xact_Policy>; }
-struct TArgs_pg_last_wal_receive_lsn_Policy {
+TExecFunc arrow_pg_read_binary_file_all() { return TGenericExec<TPgDirectFunc<&pg_read_binary_file_all>, true, false, TArgs_pg_read_binary_file_all_Policy>({}); }
+struct TArgs_pg_read_binary_file_off_len_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_pg_last_wal_receive_lsn() { return &GenericExec<TPgDirectFunc<&pg_last_wal_receive_lsn>, true, true, TArgs_pg_last_wal_receive_lsn_Policy>; }
-struct TArgs_pg_last_wal_replay_lsn_Policy {
+TExecFunc arrow_pg_read_binary_file_off_len() { return TGenericExec<TPgDirectFunc<&pg_read_binary_file_off_len>, true, false, TArgs_pg_read_binary_file_off_len_Policy>({}); }
+struct TArgs_pg_read_file_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_pg_last_wal_replay_lsn() { return &GenericExec<TPgDirectFunc<&pg_last_wal_replay_lsn>, true, true, TArgs_pg_last_wal_replay_lsn_Policy>; }
-struct TArgs_pg_last_xact_replay_timestamp_Policy {
+TExecFunc arrow_pg_read_file() { return TGenericExec<TPgDirectFunc<&pg_read_file>, true, false, TArgs_pg_read_file_Policy>({}); }
+struct TArgs_pg_read_file_all_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_last_xact_replay_timestamp() { return &GenericExec<TPgDirectFunc<&pg_last_xact_replay_timestamp>, true, true, TArgs_pg_last_xact_replay_timestamp_Policy>; }
-struct TArgs_pg_lsn_cmp_Policy {
+TExecFunc arrow_pg_read_file_all() { return TGenericExec<TPgDirectFunc<&pg_read_file_all>, true, false, TArgs_pg_read_file_all_Policy>({}); }
+struct TArgs_pg_read_file_off_len_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_pg_lsn_cmp() { return &GenericExec<TPgDirectFunc<&pg_lsn_cmp>, true, true, TArgs_pg_lsn_cmp_Policy>; }
-struct TArgs_pg_lsn_eq_Policy {
+TExecFunc arrow_pg_read_file_off_len() { return TGenericExec<TPgDirectFunc<&pg_read_file_off_len>, true, false, TArgs_pg_read_file_off_len_Policy>({}); }
+struct TArgs_pg_read_file_v2_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 4> IsFixedArg = {false,true,true,true};
 };
-TExecFunc arrow_pg_lsn_eq() { return &GenericExec<TPgDirectFunc<&pg_lsn_eq>, true, true, TArgs_pg_lsn_eq_Policy>; }
-struct TArgs_pg_lsn_ge_Policy {
+TExecFunc arrow_pg_read_file_v2() { return TGenericExec<TPgDirectFunc<&pg_read_file_v2>, true, false, TArgs_pg_read_file_v2_Policy>({}); }
+struct TArgs_pg_relation_is_updatable_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_pg_lsn_ge() { return &GenericExec<TPgDirectFunc<&pg_lsn_ge>, true, true, TArgs_pg_lsn_ge_Policy>; }
-struct TArgs_pg_lsn_gt_Policy {
+TExecFunc arrow_pg_relation_is_updatable() { return TGenericExec<TPgDirectFunc<&pg_relation_is_updatable>, true, true, TArgs_pg_relation_is_updatable_Policy>({}); }
+struct TArgs_pg_replication_slot_advance_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_pg_lsn_gt() { return &GenericExec<TPgDirectFunc<&pg_lsn_gt>, true, true, TArgs_pg_lsn_gt_Policy>; }
-struct TArgs_pg_lsn_hash_Policy {
+TExecFunc arrow_pg_replication_slot_advance() { return TGenericExec<TPgDirectFunc<&pg_replication_slot_advance>, true, false, TArgs_pg_replication_slot_advance_Policy>({}); }
+struct TArgs_pg_sleep_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_lsn_hash() { return &GenericExec<TPgDirectFunc<&pg_lsn_hash>, true, true, TArgs_pg_lsn_hash_Policy>; }
-struct TArgs_pg_lsn_hash_extended_Policy {
+TExecFunc arrow_pg_sleep() { return TGenericExec<TPgDirectFunc<&pg_sleep>, true, true, TArgs_pg_sleep_Policy>({}); }
+struct TArgs_pg_snapshot_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_lsn_hash_extended() { return &GenericExec<TPgDirectFunc<&pg_lsn_hash_extended>, true, true, TArgs_pg_lsn_hash_extended_Policy>; }
-struct TArgs_pg_lsn_in_Policy {
+TExecFunc arrow_pg_snapshot_in() { return TGenericExec<TPgDirectFunc<&pg_snapshot_in>, true, false, TArgs_pg_snapshot_in_Policy>({}); }
+struct TArgs_pg_snapshot_out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_lsn_in() { return &GenericExec<TPgDirectFunc<&pg_lsn_in>, true, true, TArgs_pg_lsn_in_Policy>; }
-struct TArgs_pg_lsn_larger_Policy {
+TExecFunc arrow_pg_snapshot_out() { return TGenericExec<TPgDirectFunc<&pg_snapshot_out>, true, false, TArgs_pg_snapshot_out_Policy>({}); }
+struct TArgs_pg_snapshot_recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_lsn_larger() { return &GenericExec<TPgDirectFunc<&pg_lsn_larger>, true, true, TArgs_pg_lsn_larger_Policy>; }
-struct TArgs_pg_lsn_le_Policy {
+TExecFunc arrow_pg_snapshot_recv() { return TGenericExec<TPgDirectFunc<&pg_snapshot_recv>, true, false, TArgs_pg_snapshot_recv_Policy>({}); }
+struct TArgs_pg_snapshot_send_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_lsn_le() { return &GenericExec<TPgDirectFunc<&pg_lsn_le>, true, true, TArgs_pg_lsn_le_Policy>; }
-struct TArgs_pg_lsn_lt_Policy {
+TExecFunc arrow_pg_snapshot_send() { return TGenericExec<TPgDirectFunc<&pg_snapshot_send>, true, false, TArgs_pg_snapshot_send_Policy>({}); }
+struct TArgs_pg_snapshot_xmax_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_lsn_lt() { return &GenericExec<TPgDirectFunc<&pg_lsn_lt>, true, true, TArgs_pg_lsn_lt_Policy>; }
-struct TArgs_pg_lsn_mi_Policy {
+TExecFunc arrow_pg_snapshot_xmax() { return TGenericExec<TPgDirectFunc<&pg_snapshot_xmax>, true, true, TArgs_pg_snapshot_xmax_Policy>({}); }
+struct TArgs_pg_snapshot_xmin_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_lsn_mi() { return &GenericExec<TPgDirectFunc<&pg_lsn_mi>, true, false, TArgs_pg_lsn_mi_Policy>; }
-struct TArgs_pg_lsn_mii_Policy {
+TExecFunc arrow_pg_snapshot_xmin() { return TGenericExec<TPgDirectFunc<&pg_snapshot_xmin>, true, true, TArgs_pg_snapshot_xmin_Policy>({}); }
+struct TArgs_pg_stat_file_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_pg_lsn_mii() { return &GenericExec<TPgDirectFunc<&pg_lsn_mii>, true, true, TArgs_pg_lsn_mii_Policy>; }
-struct TArgs_pg_lsn_ne_Policy {
+TExecFunc arrow_pg_stat_file() { return TGenericExec<TPgDirectFunc<&pg_stat_file>, true, false, TArgs_pg_stat_file_Policy>({}); }
+struct TArgs_pg_stat_file_1arg_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_lsn_ne() { return &GenericExec<TPgDirectFunc<&pg_lsn_ne>, true, true, TArgs_pg_lsn_ne_Policy>; }
-struct TArgs_pg_lsn_out_Policy {
+TExecFunc arrow_pg_stat_file_1arg() { return TGenericExec<TPgDirectFunc<&pg_stat_file_1arg>, true, false, TArgs_pg_stat_file_1arg_Policy>({}); }
+struct TArgs_pg_tablespace_location_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_lsn_out() { return &GenericExec<TPgDirectFunc<&pg_lsn_out>, true, false, TArgs_pg_lsn_out_Policy>; }
-struct TArgs_pg_lsn_pli_Policy {
+TExecFunc arrow_pg_tablespace_location() { return TGenericExec<TPgDirectFunc<&pg_tablespace_location>, true, false, TArgs_pg_tablespace_location_Policy>({}); }
+struct TArgs_pg_typeof_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_pg_typeof() { return TGenericExec<TPgDirectFunc<&pg_typeof>, false, true, TArgs_pg_typeof_Policy>({}); }
+struct TArgs_pg_visible_in_snapshot_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_pg_lsn_pli() { return &GenericExec<TPgDirectFunc<&pg_lsn_pli>, true, true, TArgs_pg_lsn_pli_Policy>; }
-struct TArgs_pg_lsn_recv_Policy {
+TExecFunc arrow_pg_visible_in_snapshot() { return TGenericExec<TPgDirectFunc<&pg_visible_in_snapshot>, true, true, TArgs_pg_visible_in_snapshot_Policy>({}); }
+struct TArgs_pg_xact_status_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_lsn_recv() { return &GenericExec<TPgDirectFunc<&pg_lsn_recv>, true, true, TArgs_pg_lsn_recv_Policy>; }
-struct TArgs_pg_lsn_send_Policy {
+TExecFunc arrow_pg_xact_status() { return TGenericExec<TPgDirectFunc<&pg_xact_status>, true, false, TArgs_pg_xact_status_Policy>({}); }
+struct TArgs_point_above_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_lsn_send() { return &GenericExec<TPgDirectFunc<&pg_lsn_send>, true, false, TArgs_pg_lsn_send_Policy>; }
-struct TArgs_pg_lsn_smaller_Policy {
+TExecFunc arrow_point_above() { return TGenericExec<TPgDirectFunc<&point_above>, true, true, TArgs_point_above_Policy>({}); }
+struct TArgs_point_add_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_lsn_smaller() { return &GenericExec<TPgDirectFunc<&pg_lsn_smaller>, true, true, TArgs_pg_lsn_smaller_Policy>; }
-struct TArgs_pg_my_temp_schema_Policy {
+TExecFunc arrow_point_add() { return TGenericExec<TPgDirectFunc<&point_add>, true, false, TArgs_point_add_Policy>({}); }
+struct TArgs_point_below_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_my_temp_schema() { return &GenericExec<TPgDirectFunc<&pg_my_temp_schema>, true, true, TArgs_pg_my_temp_schema_Policy>; }
-struct TArgs_pg_notification_queue_usage_Policy {
+TExecFunc arrow_point_below() { return TGenericExec<TPgDirectFunc<&point_below>, true, true, TArgs_point_below_Policy>({}); }
+struct TArgs_point_box_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_notification_queue_usage() { return &GenericExec<TPgDirectFunc<&pg_notification_queue_usage>, true, true, TArgs_pg_notification_queue_usage_Policy>; }
-struct TArgs_pg_notify_Policy {
+TExecFunc arrow_point_box() { return TGenericExec<TPgDirectFunc<&point_box>, true, false, TArgs_point_box_Policy>({}); }
+struct TArgs_point_distance_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_notify() { return &GenericExec<TPgDirectFunc<&pg_notify>, false, true, TArgs_pg_notify_Policy>; }
-struct TArgs_pg_opclass_is_visible_Policy {
+TExecFunc arrow_point_distance() { return TGenericExec<TPgDirectFunc<&point_distance>, true, true, TArgs_point_distance_Policy>({}); }
+struct TArgs_point_div_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_opclass_is_visible() { return &GenericExec<TPgDirectFunc<&pg_opclass_is_visible>, true, true, TArgs_pg_opclass_is_visible_Policy>; }
-struct TArgs_pg_operator_is_visible_Policy {
+TExecFunc arrow_point_div() { return TGenericExec<TPgDirectFunc<&point_div>, true, false, TArgs_point_div_Policy>({}); }
+struct TArgs_point_eq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_operator_is_visible() { return &GenericExec<TPgDirectFunc<&pg_operator_is_visible>, true, true, TArgs_pg_operator_is_visible_Policy>; }
-struct TArgs_pg_opfamily_is_visible_Policy {
+TExecFunc arrow_point_eq() { return TGenericExec<TPgDirectFunc<&point_eq>, true, true, TArgs_point_eq_Policy>({}); }
+struct TArgs_point_horiz_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_opfamily_is_visible() { return &GenericExec<TPgDirectFunc<&pg_opfamily_is_visible>, true, true, TArgs_pg_opfamily_is_visible_Policy>; }
-struct TArgs_pg_partition_root_Policy {
+TExecFunc arrow_point_horiz() { return TGenericExec<TPgDirectFunc<&point_horiz>, true, true, TArgs_point_horiz_Policy>({}); }
+struct TArgs_point_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_partition_root() { return &GenericExec<TPgDirectFunc<&pg_partition_root>, true, true, TArgs_pg_partition_root_Policy>; }
-struct TArgs_pg_promote_Policy {
+TExecFunc arrow_point_in() { return TGenericExec<TPgDirectFunc<&point_in>, true, false, TArgs_point_in_Policy>({}); }
+struct TArgs_point_left_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_promote() { return &GenericExec<TPgDirectFunc<&pg_promote>, true, true, TArgs_pg_promote_Policy>; }
-struct TArgs_pg_relation_is_publishable_Policy {
+TExecFunc arrow_point_left() { return TGenericExec<TPgDirectFunc<&point_left>, true, true, TArgs_point_left_Policy>({}); }
+struct TArgs_point_mul_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_relation_is_publishable() { return &GenericExec<TPgDirectFunc<&pg_relation_is_publishable>, true, true, TArgs_pg_relation_is_publishable_Policy>; }
-struct TArgs_pg_safe_snapshot_blocking_pids_Policy {
+TExecFunc arrow_point_mul() { return TGenericExec<TPgDirectFunc<&point_mul>, true, false, TArgs_point_mul_Policy>({}); }
+struct TArgs_point_ne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_safe_snapshot_blocking_pids() { return &GenericExec<TPgDirectFunc<&pg_safe_snapshot_blocking_pids>, true, false, TArgs_pg_safe_snapshot_blocking_pids_Policy>; }
-struct TArgs_pg_start_backup_Policy {
+TExecFunc arrow_point_ne() { return TGenericExec<TPgDirectFunc<&point_ne>, true, true, TArgs_point_ne_Policy>({}); }
+struct TArgs_point_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_start_backup() { return &GenericExec<TPgDirectFunc<&pg_start_backup>, true, true, TArgs_pg_start_backup_Policy>; }
-struct TArgs_pg_statistics_obj_is_visible_Policy {
+TExecFunc arrow_point_out() { return TGenericExec<TPgDirectFunc<&point_out>, true, false, TArgs_point_out_Policy>({}); }
+struct TArgs_point_recv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_pg_statistics_obj_is_visible() { return &GenericExec<TPgDirectFunc<&pg_statistics_obj_is_visible>, true, true, TArgs_pg_statistics_obj_is_visible_Policy>; }
-struct TArgs_pg_stop_backup_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
-};
-TExecFunc arrow_pg_stop_backup() { return &GenericExec<TPgDirectFunc<&pg_stop_backup>, true, true, TArgs_pg_stop_backup_Policy>; }
-struct TArgs_pg_switch_wal_Policy {
+TExecFunc arrow_point_recv() { return TGenericExec<TPgDirectFunc<&point_recv>, true, false, TArgs_point_recv_Policy>({}); }
+struct TArgs_point_right_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_switch_wal() { return &GenericExec<TPgDirectFunc<&pg_switch_wal>, true, true, TArgs_pg_switch_wal_Policy>; }
-struct TArgs_pg_table_is_visible_Policy {
+TExecFunc arrow_point_right() { return TGenericExec<TPgDirectFunc<&point_right>, true, true, TArgs_point_right_Policy>({}); }
+struct TArgs_point_send_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_table_is_visible() { return &GenericExec<TPgDirectFunc<&pg_table_is_visible>, true, true, TArgs_pg_table_is_visible_Policy>; }
-struct TArgs_pg_try_advisory_lock_int4_Policy {
+TExecFunc arrow_point_send() { return TGenericExec<TPgDirectFunc<&point_send>, true, false, TArgs_point_send_Policy>({}); }
+struct TArgs_point_slope_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_try_advisory_lock_int4() { return &GenericExec<TPgDirectFunc<&pg_try_advisory_lock_int4>, true, true, TArgs_pg_try_advisory_lock_int4_Policy>; }
-struct TArgs_pg_try_advisory_lock_int8_Policy {
+TExecFunc arrow_point_slope() { return TGenericExec<TPgDirectFunc<&point_slope>, true, true, TArgs_point_slope_Policy>({}); }
+struct TArgs_point_sub_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_try_advisory_lock_int8() { return &GenericExec<TPgDirectFunc<&pg_try_advisory_lock_int8>, true, true, TArgs_pg_try_advisory_lock_int8_Policy>; }
-struct TArgs_pg_try_advisory_lock_shared_int4_Policy {
+TExecFunc arrow_point_sub() { return TGenericExec<TPgDirectFunc<&point_sub>, true, false, TArgs_point_sub_Policy>({}); }
+struct TArgs_point_vert_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_try_advisory_lock_shared_int4() { return &GenericExec<TPgDirectFunc<&pg_try_advisory_lock_shared_int4>, true, true, TArgs_pg_try_advisory_lock_shared_int4_Policy>; }
-struct TArgs_pg_try_advisory_lock_shared_int8_Policy {
+TExecFunc arrow_point_vert() { return TGenericExec<TPgDirectFunc<&point_vert>, true, true, TArgs_point_vert_Policy>({}); }
+struct TArgs_points_box_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_try_advisory_lock_shared_int8() { return &GenericExec<TPgDirectFunc<&pg_try_advisory_lock_shared_int8>, true, true, TArgs_pg_try_advisory_lock_shared_int8_Policy>; }
-struct TArgs_pg_try_advisory_xact_lock_int4_Policy {
+TExecFunc arrow_points_box() { return TGenericExec<TPgDirectFunc<&points_box>, true, false, TArgs_points_box_Policy>({}); }
+struct TArgs_poly_above_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_try_advisory_xact_lock_int4() { return &GenericExec<TPgDirectFunc<&pg_try_advisory_xact_lock_int4>, true, true, TArgs_pg_try_advisory_xact_lock_int4_Policy>; }
-struct TArgs_pg_try_advisory_xact_lock_int8_Policy {
+TExecFunc arrow_poly_above() { return TGenericExec<TPgDirectFunc<&poly_above>, true, true, TArgs_poly_above_Policy>({}); }
+struct TArgs_poly_below_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_try_advisory_xact_lock_int8() { return &GenericExec<TPgDirectFunc<&pg_try_advisory_xact_lock_int8>, true, true, TArgs_pg_try_advisory_xact_lock_int8_Policy>; }
-struct TArgs_pg_try_advisory_xact_lock_shared_int4_Policy {
+TExecFunc arrow_poly_below() { return TGenericExec<TPgDirectFunc<&poly_below>, true, true, TArgs_poly_below_Policy>({}); }
+struct TArgs_poly_box_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_try_advisory_xact_lock_shared_int4() { return &GenericExec<TPgDirectFunc<&pg_try_advisory_xact_lock_shared_int4>, true, true, TArgs_pg_try_advisory_xact_lock_shared_int4_Policy>; }
-struct TArgs_pg_try_advisory_xact_lock_shared_int8_Policy {
+TExecFunc arrow_poly_box() { return TGenericExec<TPgDirectFunc<&poly_box>, true, false, TArgs_poly_box_Policy>({}); }
+struct TArgs_poly_center_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_try_advisory_xact_lock_shared_int8() { return &GenericExec<TPgDirectFunc<&pg_try_advisory_xact_lock_shared_int8>, true, true, TArgs_pg_try_advisory_xact_lock_shared_int8_Policy>; }
-struct TArgs_pg_ts_config_is_visible_Policy {
+TExecFunc arrow_poly_center() { return TGenericExec<TPgDirectFunc<&poly_center>, true, false, TArgs_poly_center_Policy>({}); }
+struct TArgs_poly_circle_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_ts_config_is_visible() { return &GenericExec<TPgDirectFunc<&pg_ts_config_is_visible>, true, true, TArgs_pg_ts_config_is_visible_Policy>; }
-struct TArgs_pg_ts_dict_is_visible_Policy {
+TExecFunc arrow_poly_circle() { return TGenericExec<TPgDirectFunc<&poly_circle>, true, false, TArgs_poly_circle_Policy>({}); }
+struct TArgs_poly_contain_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_ts_dict_is_visible() { return &GenericExec<TPgDirectFunc<&pg_ts_dict_is_visible>, true, true, TArgs_pg_ts_dict_is_visible_Policy>; }
-struct TArgs_pg_ts_parser_is_visible_Policy {
+TExecFunc arrow_poly_contain() { return TGenericExec<TPgDirectFunc<&poly_contain>, true, true, TArgs_poly_contain_Policy>({}); }
+struct TArgs_poly_contain_pt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_ts_parser_is_visible() { return &GenericExec<TPgDirectFunc<&pg_ts_parser_is_visible>, true, true, TArgs_pg_ts_parser_is_visible_Policy>; }
-struct TArgs_pg_ts_template_is_visible_Policy {
+TExecFunc arrow_poly_contain_pt() { return TGenericExec<TPgDirectFunc<&poly_contain_pt>, true, true, TArgs_poly_contain_pt_Policy>({}); }
+struct TArgs_poly_contained_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_ts_template_is_visible() { return &GenericExec<TPgDirectFunc<&pg_ts_template_is_visible>, true, true, TArgs_pg_ts_template_is_visible_Policy>; }
-struct TArgs_pg_type_is_visible_Policy {
+TExecFunc arrow_poly_contained() { return TGenericExec<TPgDirectFunc<&poly_contained>, true, true, TArgs_poly_contained_Policy>({}); }
+struct TArgs_poly_distance_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_type_is_visible() { return &GenericExec<TPgDirectFunc<&pg_type_is_visible>, true, true, TArgs_pg_type_is_visible_Policy>; }
-struct TArgs_pg_wal_lsn_diff_Policy {
+TExecFunc arrow_poly_distance() { return TGenericExec<TPgDirectFunc<&poly_distance>, true, true, TArgs_poly_distance_Policy>({}); }
+struct TArgs_poly_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_wal_lsn_diff() { return &GenericExec<TPgDirectFunc<&pg_wal_lsn_diff>, true, false, TArgs_pg_wal_lsn_diff_Policy>; }
-struct TArgs_pg_wal_replay_pause_Policy {
+TExecFunc arrow_poly_in() { return TGenericExec<TPgDirectFunc<&poly_in>, true, false, TArgs_poly_in_Policy>({}); }
+struct TArgs_poly_left_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_wal_replay_pause() { return &GenericExec<TPgDirectFunc<&pg_wal_replay_pause>, true, true, TArgs_pg_wal_replay_pause_Policy>; }
-struct TArgs_pg_wal_replay_resume_Policy {
+TExecFunc arrow_poly_left() { return TGenericExec<TPgDirectFunc<&poly_left>, true, true, TArgs_poly_left_Policy>({}); }
+struct TArgs_poly_npoints_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_wal_replay_resume() { return &GenericExec<TPgDirectFunc<&pg_wal_replay_resume>, true, true, TArgs_pg_wal_replay_resume_Policy>; }
-struct TArgs_pg_walfile_name_Policy {
+TExecFunc arrow_poly_npoints() { return TGenericExec<TPgDirectFunc<&poly_npoints>, true, true, TArgs_poly_npoints_Policy>({}); }
+struct TArgs_poly_out_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_pg_walfile_name() { return &GenericExec<TPgDirectFunc<&pg_walfile_name>, true, false, TArgs_pg_walfile_name_Policy>; }
-struct TArgs_pg_walfile_name_offset_Policy {
+TExecFunc arrow_poly_out() { return TGenericExec<TPgDirectFunc<&poly_out>, true, false, TArgs_poly_out_Policy>({}); }
+struct TArgs_poly_overabove_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_walfile_name_offset() { return &GenericExec<TPgDirectFunc<&pg_walfile_name_offset>, true, false, TArgs_pg_walfile_name_offset_Policy>; }
-struct TArgs_pg_xact_commit_timestamp_Policy {
+TExecFunc arrow_poly_overabove() { return TGenericExec<TPgDirectFunc<&poly_overabove>, true, true, TArgs_poly_overabove_Policy>({}); }
+struct TArgs_poly_overbelow_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_xact_commit_timestamp() { return &GenericExec<TPgDirectFunc<&pg_xact_commit_timestamp>, true, true, TArgs_pg_xact_commit_timestamp_Policy>; }
-struct TArgs_pg_xact_commit_timestamp_origin_Policy {
+TExecFunc arrow_poly_overbelow() { return TGenericExec<TPgDirectFunc<&poly_overbelow>, true, true, TArgs_poly_overbelow_Policy>({}); }
+struct TArgs_poly_overlap_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_pg_xact_commit_timestamp_origin() { return &GenericExec<TPgDirectFunc<&pg_xact_commit_timestamp_origin>, true, false, TArgs_pg_xact_commit_timestamp_origin_Policy>; }
-struct TArgs_query_to_xml_Policy {
+TExecFunc arrow_poly_overlap() { return TGenericExec<TPgDirectFunc<&poly_overlap>, true, true, TArgs_poly_overlap_Policy>({}); }
+struct TArgs_poly_overleft_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,true,true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_query_to_xml() { return &GenericExec<TPgDirectFunc<&query_to_xml>, true, false, TArgs_query_to_xml_Policy>; }
-struct TArgs_query_to_xml_and_xmlschema_Policy {
+TExecFunc arrow_poly_overleft() { return TGenericExec<TPgDirectFunc<&poly_overleft>, true, true, TArgs_poly_overleft_Policy>({}); }
+struct TArgs_poly_overright_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,true,true,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_query_to_xml_and_xmlschema() { return &GenericExec<TPgDirectFunc<&query_to_xml_and_xmlschema>, true, false, TArgs_query_to_xml_and_xmlschema_Policy>; }
-struct TArgs_query_to_xmlschema_Policy {
+TExecFunc arrow_poly_overright() { return TGenericExec<TPgDirectFunc<&poly_overright>, true, true, TArgs_poly_overright_Policy>({}); }
+struct TArgs_poly_path_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,true,true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_query_to_xmlschema() { return &GenericExec<TPgDirectFunc<&query_to_xmlschema>, true, false, TArgs_query_to_xmlschema_Policy>; }
-struct TArgs_radians_Policy {
+TExecFunc arrow_poly_path() { return TGenericExec<TPgDirectFunc<&poly_path>, true, false, TArgs_poly_path_Policy>({}); }
+struct TArgs_poly_recv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_radians() { return &GenericExec<TPgDirectFunc<&radians>, true, true, TArgs_radians_Policy>; }
-struct TArgs_range_adjacent_multirange_Policy {
+TExecFunc arrow_poly_recv() { return TGenericExec<TPgDirectFunc<&poly_recv>, true, false, TArgs_poly_recv_Policy>({}); }
+struct TArgs_poly_right_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_range_adjacent_multirange() { return &GenericExec<TPgDirectFunc<&range_adjacent_multirange>, true, true, TArgs_range_adjacent_multirange_Policy>; }
-struct TArgs_range_after_multirange_Policy {
+TExecFunc arrow_poly_right() { return TGenericExec<TPgDirectFunc<&poly_right>, true, true, TArgs_poly_right_Policy>({}); }
+struct TArgs_poly_same_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_range_after_multirange() { return &GenericExec<TPgDirectFunc<&range_after_multirange>, true, true, TArgs_range_after_multirange_Policy>; }
-struct TArgs_range_agg_finalfn_Policy {
+TExecFunc arrow_poly_same() { return TGenericExec<TPgDirectFunc<&poly_same>, true, true, TArgs_poly_same_Policy>({}); }
+struct TArgs_poly_send_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_range_agg_finalfn() { return &GenericExec<TPgDirectFunc<&range_agg_finalfn>, false, false, TArgs_range_agg_finalfn_Policy>; }
-struct TArgs_range_agg_transfn_Policy {
+TExecFunc arrow_poly_send() { return TGenericExec<TPgDirectFunc<&poly_send>, true, false, TArgs_poly_send_Policy>({}); }
+struct TArgs_positionjoinsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
 };
-TExecFunc arrow_range_agg_transfn() { return &GenericExec<TPgDirectFunc<&range_agg_transfn>, false, true, TArgs_range_agg_transfn_Policy>; }
-struct TArgs_range_before_multirange_Policy {
+TExecFunc arrow_positionjoinsel() { return TGenericExec<TPgDirectFunc<&positionjoinsel>, true, true, TArgs_positionjoinsel_Policy>({}); }
+struct TArgs_positionsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_range_before_multirange() { return &GenericExec<TPgDirectFunc<&range_before_multirange>, true, true, TArgs_range_before_multirange_Policy>; }
-struct TArgs_range_contained_by_multirange_Policy {
+TExecFunc arrow_positionsel() { return TGenericExec<TPgDirectFunc<&positionsel>, true, true, TArgs_positionsel_Policy>({}); }
+struct TArgs_postgresql_fdw_validator_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_range_contained_by_multirange() { return &GenericExec<TPgDirectFunc<&range_contained_by_multirange>, true, true, TArgs_range_contained_by_multirange_Policy>; }
-struct TArgs_range_contains_multirange_Policy {
+TExecFunc arrow_postgresql_fdw_validator() { return TGenericExec<TPgDirectFunc<&postgresql_fdw_validator>, true, true, TArgs_postgresql_fdw_validator_Policy>({}); }
+struct TArgs_prefixjoinsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
 };
-TExecFunc arrow_range_contains_multirange() { return &GenericExec<TPgDirectFunc<&range_contains_multirange>, true, true, TArgs_range_contains_multirange_Policy>; }
-struct TArgs_range_merge_from_multirange_Policy {
+TExecFunc arrow_prefixjoinsel() { return TGenericExec<TPgDirectFunc<&prefixjoinsel>, true, true, TArgs_prefixjoinsel_Policy>({}); }
+struct TArgs_prefixsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_range_merge_from_multirange() { return &GenericExec<TPgDirectFunc<&range_merge_from_multirange>, true, false, TArgs_range_merge_from_multirange_Policy>; }
-struct TArgs_range_overlaps_multirange_Policy {
+TExecFunc arrow_prefixsel() { return TGenericExec<TPgDirectFunc<&prefixsel>, true, true, TArgs_prefixsel_Policy>({}); }
+struct TArgs_pt_contained_circle_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_range_overlaps_multirange() { return &GenericExec<TPgDirectFunc<&range_overlaps_multirange>, true, true, TArgs_range_overlaps_multirange_Policy>; }
-struct TArgs_range_overleft_multirange_Policy {
+TExecFunc arrow_pt_contained_circle() { return TGenericExec<TPgDirectFunc<&pt_contained_circle>, true, true, TArgs_pt_contained_circle_Policy>({}); }
+struct TArgs_pt_contained_poly_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_range_overleft_multirange() { return &GenericExec<TPgDirectFunc<&range_overleft_multirange>, true, true, TArgs_range_overleft_multirange_Policy>; }
-struct TArgs_range_overright_multirange_Policy {
+TExecFunc arrow_pt_contained_poly() { return TGenericExec<TPgDirectFunc<&pt_contained_poly>, true, true, TArgs_pt_contained_poly_Policy>({}); }
+struct TArgs_quote_ident_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_range_overright_multirange() { return &GenericExec<TPgDirectFunc<&range_overright_multirange>, true, true, TArgs_range_overright_multirange_Policy>; }
-struct TArgs_rangesel_Policy {
+TExecFunc arrow_quote_ident() { return TGenericExec<TPgDirectFunc<&quote_ident>, true, false, TArgs_quote_ident_Policy>({}); }
+struct TArgs_quote_literal_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_rangesel() { return &GenericExec<TPgDirectFunc<&rangesel>, true, true, TArgs_rangesel_Policy>; }
-struct TArgs_raw_array_subscript_handler_Policy {
+TExecFunc arrow_quote_literal() { return TGenericExec<TPgDirectFunc<&quote_literal>, true, false, TArgs_quote_literal_Policy>({}); }
+struct TArgs_quote_nullable_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_raw_array_subscript_handler() { return &GenericExec<TPgDirectFunc<&raw_array_subscript_handler>, true, true, TArgs_raw_array_subscript_handler_Policy>; }
+TExecFunc arrow_quote_nullable() { return TGenericExec<TPgDirectFunc<&quote_nullable>, false, false, TArgs_quote_nullable_Policy>({}); }
 struct TArgs_regclassin_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_regclassin() { return &GenericExec<TPgDirectFunc<&regclassin>, true, true, TArgs_regclassin_Policy>; }
+TExecFunc arrow_regclassin() { return TGenericExec<TPgDirectFunc<&regclassin>, true, true, TArgs_regclassin_Policy>({}); }
 struct TArgs_regclassout_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regclassout() { return &GenericExec<TPgDirectFunc<&regclassout>, true, false, TArgs_regclassout_Policy>; }
+TExecFunc arrow_regclassout() { return TGenericExec<TPgDirectFunc<&regclassout>, true, false, TArgs_regclassout_Policy>({}); }
 struct TArgs_regclassrecv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regclassrecv() { return &GenericExec<TPgDirectFunc<&regclassrecv>, true, true, TArgs_regclassrecv_Policy>; }
+TExecFunc arrow_regclassrecv() { return TGenericExec<TPgDirectFunc<&regclassrecv>, true, true, TArgs_regclassrecv_Policy>({}); }
 struct TArgs_regclasssend_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regclasssend() { return &GenericExec<TPgDirectFunc<&regclasssend>, true, false, TArgs_regclasssend_Policy>; }
+TExecFunc arrow_regclasssend() { return TGenericExec<TPgDirectFunc<&regclasssend>, true, false, TArgs_regclasssend_Policy>({}); }
 struct TArgs_regcollationin_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_regcollationin() { return &GenericExec<TPgDirectFunc<&regcollationin>, true, true, TArgs_regcollationin_Policy>; }
+TExecFunc arrow_regcollationin() { return TGenericExec<TPgDirectFunc<&regcollationin>, true, true, TArgs_regcollationin_Policy>({}); }
 struct TArgs_regcollationout_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regcollationout() { return &GenericExec<TPgDirectFunc<&regcollationout>, true, false, TArgs_regcollationout_Policy>; }
+TExecFunc arrow_regcollationout() { return TGenericExec<TPgDirectFunc<&regcollationout>, true, false, TArgs_regcollationout_Policy>({}); }
 struct TArgs_regcollationrecv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regcollationrecv() { return &GenericExec<TPgDirectFunc<&regcollationrecv>, true, true, TArgs_regcollationrecv_Policy>; }
+TExecFunc arrow_regcollationrecv() { return TGenericExec<TPgDirectFunc<&regcollationrecv>, true, true, TArgs_regcollationrecv_Policy>({}); }
 struct TArgs_regcollationsend_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regcollationsend() { return &GenericExec<TPgDirectFunc<&regcollationsend>, true, false, TArgs_regcollationsend_Policy>; }
+TExecFunc arrow_regcollationsend() { return TGenericExec<TPgDirectFunc<&regcollationsend>, true, false, TArgs_regcollationsend_Policy>({}); }
 struct TArgs_regconfigin_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_regconfigin() { return &GenericExec<TPgDirectFunc<&regconfigin>, true, true, TArgs_regconfigin_Policy>; }
+TExecFunc arrow_regconfigin() { return TGenericExec<TPgDirectFunc<&regconfigin>, true, true, TArgs_regconfigin_Policy>({}); }
 struct TArgs_regconfigout_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regconfigout() { return &GenericExec<TPgDirectFunc<&regconfigout>, true, false, TArgs_regconfigout_Policy>; }
+TExecFunc arrow_regconfigout() { return TGenericExec<TPgDirectFunc<&regconfigout>, true, false, TArgs_regconfigout_Policy>({}); }
 struct TArgs_regconfigrecv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regconfigrecv() { return &GenericExec<TPgDirectFunc<&regconfigrecv>, true, true, TArgs_regconfigrecv_Policy>; }
+TExecFunc arrow_regconfigrecv() { return TGenericExec<TPgDirectFunc<&regconfigrecv>, true, true, TArgs_regconfigrecv_Policy>({}); }
 struct TArgs_regconfigsend_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regconfigsend() { return &GenericExec<TPgDirectFunc<&regconfigsend>, true, false, TArgs_regconfigsend_Policy>; }
+TExecFunc arrow_regconfigsend() { return TGenericExec<TPgDirectFunc<&regconfigsend>, true, false, TArgs_regconfigsend_Policy>({}); }
 struct TArgs_regdictionaryin_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_regdictionaryin() { return &GenericExec<TPgDirectFunc<&regdictionaryin>, true, true, TArgs_regdictionaryin_Policy>; }
+TExecFunc arrow_regdictionaryin() { return TGenericExec<TPgDirectFunc<&regdictionaryin>, true, true, TArgs_regdictionaryin_Policy>({}); }
 struct TArgs_regdictionaryout_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regdictionaryout() { return &GenericExec<TPgDirectFunc<&regdictionaryout>, true, false, TArgs_regdictionaryout_Policy>; }
+TExecFunc arrow_regdictionaryout() { return TGenericExec<TPgDirectFunc<&regdictionaryout>, true, false, TArgs_regdictionaryout_Policy>({}); }
 struct TArgs_regdictionaryrecv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regdictionaryrecv() { return &GenericExec<TPgDirectFunc<&regdictionaryrecv>, true, true, TArgs_regdictionaryrecv_Policy>; }
+TExecFunc arrow_regdictionaryrecv() { return TGenericExec<TPgDirectFunc<&regdictionaryrecv>, true, true, TArgs_regdictionaryrecv_Policy>({}); }
 struct TArgs_regdictionarysend_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regdictionarysend() { return &GenericExec<TPgDirectFunc<&regdictionarysend>, true, false, TArgs_regdictionarysend_Policy>; }
-struct TArgs_regexp_match_Policy {
+TExecFunc arrow_regdictionarysend() { return TGenericExec<TPgDirectFunc<&regdictionarysend>, true, false, TArgs_regdictionarysend_Policy>({}); }
+struct TArgs_regexeqjoinsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
 };
-TExecFunc arrow_regexp_match() { return &GenericExec<TPgDirectFunc<&regexp_match>, true, false, TArgs_regexp_match_Policy>; }
-struct TArgs_regexp_match_no_flags_Policy {
+TExecFunc arrow_regexeqjoinsel() { return TGenericExec<TPgDirectFunc<&regexeqjoinsel>, true, true, TArgs_regexeqjoinsel_Policy>({}); }
+struct TArgs_regexeqsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_regexp_match_no_flags() { return &GenericExec<TPgDirectFunc<&regexp_match_no_flags>, true, false, TArgs_regexp_match_no_flags_Policy>; }
-struct TArgs_regexp_split_to_array_Policy {
+TExecFunc arrow_regexeqsel() { return TGenericExec<TPgDirectFunc<&regexeqsel>, true, true, TArgs_regexeqsel_Policy>({}); }
+struct TArgs_regexnejoinsel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
 };
-TExecFunc arrow_regexp_split_to_array() { return &GenericExec<TPgDirectFunc<&regexp_split_to_array>, true, false, TArgs_regexp_split_to_array_Policy>; }
-struct TArgs_regexp_split_to_array_no_flags_Policy {
+TExecFunc arrow_regexnejoinsel() { return TGenericExec<TPgDirectFunc<&regexnejoinsel>, true, true, TArgs_regexnejoinsel_Policy>({}); }
+struct TArgs_regexnesel_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_regexp_split_to_array_no_flags() { return &GenericExec<TPgDirectFunc<&regexp_split_to_array_no_flags>, true, false, TArgs_regexp_split_to_array_no_flags_Policy>; }
+TExecFunc arrow_regexnesel() { return TGenericExec<TPgDirectFunc<&regexnesel>, true, true, TArgs_regexnesel_Policy>({}); }
 struct TArgs_regnamespacein_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_regnamespacein() { return &GenericExec<TPgDirectFunc<&regnamespacein>, true, true, TArgs_regnamespacein_Policy>; }
+TExecFunc arrow_regnamespacein() { return TGenericExec<TPgDirectFunc<&regnamespacein>, true, true, TArgs_regnamespacein_Policy>({}); }
 struct TArgs_regnamespaceout_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regnamespaceout() { return &GenericExec<TPgDirectFunc<&regnamespaceout>, true, false, TArgs_regnamespaceout_Policy>; }
+TExecFunc arrow_regnamespaceout() { return TGenericExec<TPgDirectFunc<&regnamespaceout>, true, false, TArgs_regnamespaceout_Policy>({}); }
 struct TArgs_regnamespacerecv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regnamespacerecv() { return &GenericExec<TPgDirectFunc<&regnamespacerecv>, true, true, TArgs_regnamespacerecv_Policy>; }
+TExecFunc arrow_regnamespacerecv() { return TGenericExec<TPgDirectFunc<&regnamespacerecv>, true, true, TArgs_regnamespacerecv_Policy>({}); }
 struct TArgs_regnamespacesend_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regnamespacesend() { return &GenericExec<TPgDirectFunc<&regnamespacesend>, true, false, TArgs_regnamespacesend_Policy>; }
+TExecFunc arrow_regnamespacesend() { return TGenericExec<TPgDirectFunc<&regnamespacesend>, true, false, TArgs_regnamespacesend_Policy>({}); }
 struct TArgs_regoperatorin_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_regoperatorin() { return &GenericExec<TPgDirectFunc<&regoperatorin>, true, true, TArgs_regoperatorin_Policy>; }
+TExecFunc arrow_regoperatorin() { return TGenericExec<TPgDirectFunc<&regoperatorin>, true, true, TArgs_regoperatorin_Policy>({}); }
 struct TArgs_regoperatorout_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regoperatorout() { return &GenericExec<TPgDirectFunc<&regoperatorout>, true, false, TArgs_regoperatorout_Policy>; }
+TExecFunc arrow_regoperatorout() { return TGenericExec<TPgDirectFunc<&regoperatorout>, true, false, TArgs_regoperatorout_Policy>({}); }
 struct TArgs_regoperatorrecv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regoperatorrecv() { return &GenericExec<TPgDirectFunc<&regoperatorrecv>, true, true, TArgs_regoperatorrecv_Policy>; }
+TExecFunc arrow_regoperatorrecv() { return TGenericExec<TPgDirectFunc<&regoperatorrecv>, true, true, TArgs_regoperatorrecv_Policy>({}); }
 struct TArgs_regoperatorsend_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regoperatorsend() { return &GenericExec<TPgDirectFunc<&regoperatorsend>, true, false, TArgs_regoperatorsend_Policy>; }
+TExecFunc arrow_regoperatorsend() { return TGenericExec<TPgDirectFunc<&regoperatorsend>, true, false, TArgs_regoperatorsend_Policy>({}); }
 struct TArgs_regoperin_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_regoperin() { return &GenericExec<TPgDirectFunc<&regoperin>, true, true, TArgs_regoperin_Policy>; }
+TExecFunc arrow_regoperin() { return TGenericExec<TPgDirectFunc<&regoperin>, true, true, TArgs_regoperin_Policy>({}); }
 struct TArgs_regoperout_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regoperout() { return &GenericExec<TPgDirectFunc<&regoperout>, true, false, TArgs_regoperout_Policy>; }
+TExecFunc arrow_regoperout() { return TGenericExec<TPgDirectFunc<&regoperout>, true, false, TArgs_regoperout_Policy>({}); }
 struct TArgs_regoperrecv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regoperrecv() { return &GenericExec<TPgDirectFunc<&regoperrecv>, true, true, TArgs_regoperrecv_Policy>; }
+TExecFunc arrow_regoperrecv() { return TGenericExec<TPgDirectFunc<&regoperrecv>, true, true, TArgs_regoperrecv_Policy>({}); }
 struct TArgs_regopersend_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regopersend() { return &GenericExec<TPgDirectFunc<&regopersend>, true, false, TArgs_regopersend_Policy>; }
+TExecFunc arrow_regopersend() { return TGenericExec<TPgDirectFunc<&regopersend>, true, false, TArgs_regopersend_Policy>({}); }
 struct TArgs_regprocedurein_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_regprocedurein() { return &GenericExec<TPgDirectFunc<&regprocedurein>, true, true, TArgs_regprocedurein_Policy>; }
+TExecFunc arrow_regprocedurein() { return TGenericExec<TPgDirectFunc<&regprocedurein>, true, true, TArgs_regprocedurein_Policy>({}); }
 struct TArgs_regprocedureout_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regprocedureout() { return &GenericExec<TPgDirectFunc<&regprocedureout>, true, false, TArgs_regprocedureout_Policy>; }
+TExecFunc arrow_regprocedureout() { return TGenericExec<TPgDirectFunc<&regprocedureout>, true, false, TArgs_regprocedureout_Policy>({}); }
 struct TArgs_regprocedurerecv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regprocedurerecv() { return &GenericExec<TPgDirectFunc<&regprocedurerecv>, true, true, TArgs_regprocedurerecv_Policy>; }
+TExecFunc arrow_regprocedurerecv() { return TGenericExec<TPgDirectFunc<&regprocedurerecv>, true, true, TArgs_regprocedurerecv_Policy>({}); }
 struct TArgs_regproceduresend_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regproceduresend() { return &GenericExec<TPgDirectFunc<&regproceduresend>, true, false, TArgs_regproceduresend_Policy>; }
+TExecFunc arrow_regproceduresend() { return TGenericExec<TPgDirectFunc<&regproceduresend>, true, false, TArgs_regproceduresend_Policy>({}); }
 struct TArgs_regprocin_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_regprocin() { return &GenericExec<TPgDirectFunc<&regprocin>, true, true, TArgs_regprocin_Policy>; }
+TExecFunc arrow_regprocin() { return TGenericExec<TPgDirectFunc<&regprocin>, true, true, TArgs_regprocin_Policy>({}); }
 struct TArgs_regprocout_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regprocout() { return &GenericExec<TPgDirectFunc<&regprocout>, true, false, TArgs_regprocout_Policy>; }
+TExecFunc arrow_regprocout() { return TGenericExec<TPgDirectFunc<&regprocout>, true, false, TArgs_regprocout_Policy>({}); }
 struct TArgs_regprocrecv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regprocrecv() { return &GenericExec<TPgDirectFunc<&regprocrecv>, true, true, TArgs_regprocrecv_Policy>; }
+TExecFunc arrow_regprocrecv() { return TGenericExec<TPgDirectFunc<&regprocrecv>, true, true, TArgs_regprocrecv_Policy>({}); }
 struct TArgs_regprocsend_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regprocsend() { return &GenericExec<TPgDirectFunc<&regprocsend>, true, false, TArgs_regprocsend_Policy>; }
+TExecFunc arrow_regprocsend() { return TGenericExec<TPgDirectFunc<&regprocsend>, true, false, TArgs_regprocsend_Policy>({}); }
 struct TArgs_regrolein_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_regrolein() { return &GenericExec<TPgDirectFunc<&regrolein>, true, true, TArgs_regrolein_Policy>; }
+TExecFunc arrow_regrolein() { return TGenericExec<TPgDirectFunc<&regrolein>, true, true, TArgs_regrolein_Policy>({}); }
 struct TArgs_regroleout_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regroleout() { return &GenericExec<TPgDirectFunc<&regroleout>, true, false, TArgs_regroleout_Policy>; }
+TExecFunc arrow_regroleout() { return TGenericExec<TPgDirectFunc<&regroleout>, true, false, TArgs_regroleout_Policy>({}); }
 struct TArgs_regrolerecv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regrolerecv() { return &GenericExec<TPgDirectFunc<&regrolerecv>, true, true, TArgs_regrolerecv_Policy>; }
+TExecFunc arrow_regrolerecv() { return TGenericExec<TPgDirectFunc<&regrolerecv>, true, true, TArgs_regrolerecv_Policy>({}); }
 struct TArgs_regrolesend_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regrolesend() { return &GenericExec<TPgDirectFunc<&regrolesend>, true, false, TArgs_regrolesend_Policy>; }
+TExecFunc arrow_regrolesend() { return TGenericExec<TPgDirectFunc<&regrolesend>, true, false, TArgs_regrolesend_Policy>({}); }
 struct TArgs_regtypein_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_regtypein() { return &GenericExec<TPgDirectFunc<&regtypein>, true, true, TArgs_regtypein_Policy>; }
+TExecFunc arrow_regtypein() { return TGenericExec<TPgDirectFunc<&regtypein>, true, true, TArgs_regtypein_Policy>({}); }
 struct TArgs_regtypeout_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regtypeout() { return &GenericExec<TPgDirectFunc<&regtypeout>, true, false, TArgs_regtypeout_Policy>; }
+TExecFunc arrow_regtypeout() { return TGenericExec<TPgDirectFunc<&regtypeout>, true, false, TArgs_regtypeout_Policy>({}); }
 struct TArgs_regtyperecv_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regtyperecv() { return &GenericExec<TPgDirectFunc<&regtyperecv>, true, true, TArgs_regtyperecv_Policy>; }
+TExecFunc arrow_regtyperecv() { return TGenericExec<TPgDirectFunc<&regtyperecv>, true, true, TArgs_regtyperecv_Policy>({}); }
 struct TArgs_regtypesend_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_regtypesend() { return &GenericExec<TPgDirectFunc<&regtypesend>, true, false, TArgs_regtypesend_Policy>; }
-struct TArgs_replace_text_Policy {
-    static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
-};
-TExecFunc arrow_replace_text() { return &GenericExec<TPgDirectFunc<&replace_text>, true, false, TArgs_replace_text_Policy>; }
+TExecFunc arrow_regtypesend() { return TGenericExec<TPgDirectFunc<&regtypesend>, true, false, TArgs_regtypesend_Policy>({}); }
 struct TArgs_row_security_active_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_row_security_active() { return &GenericExec<TPgDirectFunc<&row_security_active>, true, true, TArgs_row_security_active_Policy>; }
+TExecFunc arrow_row_security_active() { return TGenericExec<TPgDirectFunc<&row_security_active>, true, true, TArgs_row_security_active_Policy>({}); }
 struct TArgs_row_security_active_name_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_row_security_active_name() { return &GenericExec<TPgDirectFunc<&row_security_active_name>, true, true, TArgs_row_security_active_name_Policy>; }
-struct TArgs_schema_to_xml_Policy {
+TExecFunc arrow_row_security_active_name() { return TGenericExec<TPgDirectFunc<&row_security_active_name>, true, true, TArgs_row_security_active_name_Policy>({}); }
+struct TArgs_sha224_bytea_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,true,true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_schema_to_xml() { return &GenericExec<TPgDirectFunc<&schema_to_xml>, true, false, TArgs_schema_to_xml_Policy>; }
-struct TArgs_schema_to_xml_and_xmlschema_Policy {
+TExecFunc arrow_sha224_bytea() { return TGenericExec<TPgDirectFunc<&sha224_bytea>, true, false, TArgs_sha224_bytea_Policy>({}); }
+struct TArgs_sha256_bytea_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,true,true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_schema_to_xml_and_xmlschema() { return &GenericExec<TPgDirectFunc<&schema_to_xml_and_xmlschema>, true, false, TArgs_schema_to_xml_and_xmlschema_Policy>; }
-struct TArgs_schema_to_xmlschema_Policy {
+TExecFunc arrow_sha256_bytea() { return TGenericExec<TPgDirectFunc<&sha256_bytea>, true, false, TArgs_sha256_bytea_Policy>({}); }
+struct TArgs_sha384_bytea_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,true,true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_schema_to_xmlschema() { return &GenericExec<TPgDirectFunc<&schema_to_xmlschema>, true, false, TArgs_schema_to_xmlschema_Policy>; }
-struct TArgs_setseed_Policy {
+TExecFunc arrow_sha384_bytea() { return TGenericExec<TPgDirectFunc<&sha384_bytea>, true, false, TArgs_sha384_bytea_Policy>({}); }
+struct TArgs_sha512_bytea_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_setseed() { return &GenericExec<TPgDirectFunc<&setseed>, true, true, TArgs_setseed_Policy>; }
-struct TArgs_similar_escape_Policy {
+TExecFunc arrow_sha512_bytea() { return TGenericExec<TPgDirectFunc<&sha512_bytea>, true, false, TArgs_sha512_bytea_Policy>({}); }
+struct TArgs_spg_bbox_quad_config_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_similar_escape() { return &GenericExec<TPgDirectFunc<&similar_escape>, false, false, TArgs_similar_escape_Policy>; }
-struct TArgs_similar_to_escape_1_Policy {
+TExecFunc arrow_spg_bbox_quad_config() { return TGenericExec<TPgDirectFunc<&spg_bbox_quad_config>, true, true, TArgs_spg_bbox_quad_config_Policy>({}); }
+struct TArgs_spg_box_quad_choose_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_similar_to_escape_1() { return &GenericExec<TPgDirectFunc<&similar_to_escape_1>, true, false, TArgs_similar_to_escape_1_Policy>; }
-struct TArgs_similar_to_escape_2_Policy {
+TExecFunc arrow_spg_box_quad_choose() { return TGenericExec<TPgDirectFunc<&spg_box_quad_choose>, true, true, TArgs_spg_box_quad_choose_Policy>({}); }
+struct TArgs_spg_box_quad_config_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_similar_to_escape_2() { return &GenericExec<TPgDirectFunc<&similar_to_escape_2>, true, false, TArgs_similar_to_escape_2_Policy>; }
-struct TArgs_split_part_Policy {
+TExecFunc arrow_spg_box_quad_config() { return TGenericExec<TPgDirectFunc<&spg_box_quad_config>, true, true, TArgs_spg_box_quad_config_Policy>({}); }
+struct TArgs_spg_box_quad_inner_consistent_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_split_part() { return &GenericExec<TPgDirectFunc<&split_part>, true, false, TArgs_split_part_Policy>; }
-struct TArgs_string_agg_finalfn_Policy {
+TExecFunc arrow_spg_box_quad_inner_consistent() { return TGenericExec<TPgDirectFunc<&spg_box_quad_inner_consistent>, true, true, TArgs_spg_box_quad_inner_consistent_Policy>({}); }
+struct TArgs_spg_box_quad_leaf_consistent_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+};
+TExecFunc arrow_spg_box_quad_leaf_consistent() { return TGenericExec<TPgDirectFunc<&spg_box_quad_leaf_consistent>, true, true, TArgs_spg_box_quad_leaf_consistent_Policy>({}); }
+struct TArgs_spg_box_quad_picksplit_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_string_agg_finalfn() { return &GenericExec<TPgDirectFunc<&string_agg_finalfn>, false, false, TArgs_string_agg_finalfn_Policy>; }
-struct TArgs_string_agg_transfn_Policy {
+TExecFunc arrow_spg_box_quad_picksplit() { return TGenericExec<TPgDirectFunc<&spg_box_quad_picksplit>, true, true, TArgs_spg_box_quad_picksplit_Policy>({}); }
+struct TArgs_spg_poly_quad_compress_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {true,false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_string_agg_transfn() { return &GenericExec<TPgDirectFunc<&string_agg_transfn>, false, true, TArgs_string_agg_transfn_Policy>; }
-struct TArgs_table_to_xml_Policy {
+TExecFunc arrow_spg_poly_quad_compress() { return TGenericExec<TPgDirectFunc<&spg_poly_quad_compress>, true, false, TArgs_spg_poly_quad_compress_Policy>({}); }
+struct TArgs_statement_timestamp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_table_to_xml() { return &GenericExec<TPgDirectFunc<&table_to_xml>, true, false, TArgs_table_to_xml_Policy>; }
-struct TArgs_table_to_xml_and_xmlschema_Policy {
+TExecFunc arrow_statement_timestamp() { return TGenericExec<TPgDirectFunc<&statement_timestamp>, true, true, TArgs_statement_timestamp_Policy>({}); }
+struct TArgs_text_regclass_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_table_to_xml_and_xmlschema() { return &GenericExec<TPgDirectFunc<&table_to_xml_and_xmlschema>, true, false, TArgs_table_to_xml_and_xmlschema_Policy>; }
-struct TArgs_table_to_xmlschema_Policy {
+TExecFunc arrow_text_regclass() { return TGenericExec<TPgDirectFunc<&text_regclass>, true, true, TArgs_text_regclass_Policy>({}); }
+struct TArgs_texticlike_support_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_table_to_xmlschema() { return &GenericExec<TPgDirectFunc<&table_to_xmlschema>, true, false, TArgs_table_to_xmlschema_Policy>; }
-struct TArgs_text_char_Policy {
+TExecFunc arrow_texticlike_support() { return TGenericExec<TPgDirectFunc<&texticlike_support>, true, true, TArgs_texticlike_support_Policy>({}); }
+struct TArgs_texticregexeq_support_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_text_char() { return &GenericExec<TPgDirectFunc<&text_char>, true, true, TArgs_text_char_Policy>; }
-struct TArgs_text_format_nv_Policy {
+TExecFunc arrow_texticregexeq_support() { return TGenericExec<TPgDirectFunc<&texticregexeq_support>, true, true, TArgs_texticregexeq_support_Policy>({}); }
+struct TArgs_textlike_support_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_text_format_nv() { return &GenericExec<TPgDirectFunc<&text_format_nv>, false, false, TArgs_text_format_nv_Policy>; }
-struct TArgs_text_ge_Policy {
+TExecFunc arrow_textlike_support() { return TGenericExec<TPgDirectFunc<&textlike_support>, true, true, TArgs_textlike_support_Policy>({}); }
+struct TArgs_textregexeq_support_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_text_ge() { return &GenericExec<TPgDirectFunc<&text_ge>, true, true, TArgs_text_ge_Policy>; }
-struct TArgs_text_gt_Policy {
+TExecFunc arrow_textregexeq_support() { return TGenericExec<TPgDirectFunc<&textregexeq_support>, true, true, TArgs_textregexeq_support_Policy>({}); }
+struct TArgs_thesaurus_init_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_text_gt() { return &GenericExec<TPgDirectFunc<&text_gt>, true, true, TArgs_text_gt_Policy>; }
-struct TArgs_text_larger_Policy {
+TExecFunc arrow_thesaurus_init() { return TGenericExec<TPgDirectFunc<&thesaurus_init>, true, true, TArgs_thesaurus_init_Policy>({}); }
+struct TArgs_thesaurus_lexize_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
 };
-TExecFunc arrow_text_larger() { return &GenericExec<TPgDirectFunc<&text_larger>, true, false, TArgs_text_larger_Policy>; }
-struct TArgs_text_le_Policy {
+TExecFunc arrow_thesaurus_lexize() { return TGenericExec<TPgDirectFunc<&thesaurus_lexize>, true, true, TArgs_thesaurus_lexize_Policy>({}); }
+struct TArgs_tideq_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_text_le() { return &GenericExec<TPgDirectFunc<&text_le>, true, true, TArgs_text_le_Policy>; }
-struct TArgs_text_left_Policy {
+TExecFunc arrow_tideq() { return TGenericExec<TPgDirectFunc<&tideq>, true, true, TArgs_tideq_Policy>({}); }
+struct TArgs_tidge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_text_left() { return &GenericExec<TPgDirectFunc<&text_left>, true, false, TArgs_text_left_Policy>; }
-struct TArgs_text_lt_Policy {
+TExecFunc arrow_tidge() { return TGenericExec<TPgDirectFunc<&tidge>, true, true, TArgs_tidge_Policy>({}); }
+struct TArgs_tidgt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_text_lt() { return &GenericExec<TPgDirectFunc<&text_lt>, true, true, TArgs_text_lt_Policy>; }
-struct TArgs_text_name_Policy {
+TExecFunc arrow_tidgt() { return TGenericExec<TPgDirectFunc<&tidgt>, true, true, TArgs_tidgt_Policy>({}); }
+struct TArgs_tidin_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_text_name() { return &GenericExec<TPgDirectFunc<&text_name>, true, false, TArgs_text_name_Policy>; }
-struct TArgs_text_pattern_ge_Policy {
+TExecFunc arrow_tidin() { return TGenericExec<TPgDirectFunc<&tidin>, true, false, TArgs_tidin_Policy>({}); }
+struct TArgs_tidlarger_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_text_pattern_ge() { return &GenericExec<TPgDirectFunc<&text_pattern_ge>, true, true, TArgs_text_pattern_ge_Policy>; }
-struct TArgs_text_pattern_gt_Policy {
+TExecFunc arrow_tidlarger() { return TGenericExec<TPgDirectFunc<&tidlarger>, true, false, TArgs_tidlarger_Policy>({}); }
+struct TArgs_tidle_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_text_pattern_gt() { return &GenericExec<TPgDirectFunc<&text_pattern_gt>, true, true, TArgs_text_pattern_gt_Policy>; }
-struct TArgs_text_pattern_le_Policy {
+TExecFunc arrow_tidle() { return TGenericExec<TPgDirectFunc<&tidle>, true, true, TArgs_tidle_Policy>({}); }
+struct TArgs_tidlt_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_text_pattern_le() { return &GenericExec<TPgDirectFunc<&text_pattern_le>, true, true, TArgs_text_pattern_le_Policy>; }
-struct TArgs_text_pattern_lt_Policy {
+TExecFunc arrow_tidlt() { return TGenericExec<TPgDirectFunc<&tidlt>, true, true, TArgs_tidlt_Policy>({}); }
+struct TArgs_tidne_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_text_pattern_lt() { return &GenericExec<TPgDirectFunc<&text_pattern_lt>, true, true, TArgs_text_pattern_lt_Policy>; }
-struct TArgs_text_regclass_Policy {
+TExecFunc arrow_tidne() { return TGenericExec<TPgDirectFunc<&tidne>, true, true, TArgs_tidne_Policy>({}); }
+struct TArgs_tidout_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_text_regclass() { return &GenericExec<TPgDirectFunc<&text_regclass>, true, true, TArgs_text_regclass_Policy>; }
-struct TArgs_text_reverse_Policy {
+TExecFunc arrow_tidout() { return TGenericExec<TPgDirectFunc<&tidout>, true, false, TArgs_tidout_Policy>({}); }
+struct TArgs_tidrecv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_text_reverse() { return &GenericExec<TPgDirectFunc<&text_reverse>, true, false, TArgs_text_reverse_Policy>; }
-struct TArgs_text_right_Policy {
+TExecFunc arrow_tidrecv() { return TGenericExec<TPgDirectFunc<&tidrecv>, true, false, TArgs_tidrecv_Policy>({}); }
+struct TArgs_tidsend_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_text_right() { return &GenericExec<TPgDirectFunc<&text_right>, true, false, TArgs_text_right_Policy>; }
-struct TArgs_text_smaller_Policy {
+TExecFunc arrow_tidsend() { return TGenericExec<TPgDirectFunc<&tidsend>, true, false, TArgs_tidsend_Policy>({}); }
+struct TArgs_tidsmaller_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_text_smaller() { return &GenericExec<TPgDirectFunc<&text_smaller>, true, false, TArgs_text_smaller_Policy>; }
-struct TArgs_text_starts_with_Policy {
+TExecFunc arrow_tidsmaller() { return TGenericExec<TPgDirectFunc<&tidsmaller>, true, false, TArgs_tidsmaller_Policy>({}); }
+struct TArgs_timeofday_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 0> IsFixedArg = {};
 };
-TExecFunc arrow_text_starts_with() { return &GenericExec<TPgDirectFunc<&text_starts_with>, true, true, TArgs_text_starts_with_Policy>; }
-struct TArgs_text_substr_Policy {
+TExecFunc arrow_timeofday() { return TGenericExec<TPgDirectFunc<&timeofday>, true, false, TArgs_timeofday_Policy>({}); }
+struct TArgs_timestamp_age_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+};
+TExecFunc arrow_timestamp_age() { return TGenericExec<TPgDirectFunc<&timestamp_age>, true, false, TArgs_timestamp_age_Policy>({}); }
+struct TArgs_timestamp_bin_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_text_substr() { return &GenericExec<TPgDirectFunc<&text_substr>, true, false, TArgs_text_substr_Policy>; }
-struct TArgs_text_substr_no_len_Policy {
+TExecFunc arrow_timestamp_bin() { return TGenericExec<TPgDirectFunc<&timestamp_bin>, true, true, TArgs_timestamp_bin_Policy>({}); }
+struct TArgs_timestamp_cmp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_text_substr_no_len() { return &GenericExec<TPgDirectFunc<&text_substr_no_len>, true, false, TArgs_text_substr_no_len_Policy>; }
-struct TArgs_text_to_array_Policy {
+TExecFunc arrow_timestamp_cmp() { return TGenericExec<TPgDirectFunc<&timestamp_cmp>, true, true, TArgs_timestamp_cmp_Policy>({}); }
+struct TArgs_timestamp_cmp_timestamptz_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_text_to_array() { return &GenericExec<TPgDirectFunc<&text_to_array>, false, false, TArgs_text_to_array_Policy>; }
-struct TArgs_text_to_array_null_Policy {
+TExecFunc arrow_timestamp_cmp_timestamptz() { return TGenericExec<TPgDirectFunc<&timestamp_cmp_timestamptz>, true, true, TArgs_timestamp_cmp_timestamptz_Policy>({}); }
+struct TArgs_timestamp_eq_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_text_to_array_null() { return &GenericExec<TPgDirectFunc<&text_to_array_null>, false, false, TArgs_text_to_array_null_Policy>; }
-struct TArgs_textcat_Policy {
+TExecFunc arrow_timestamp_eq() { return TGenericExec<TPgDirectFunc<&timestamp_eq>, true, true, TArgs_timestamp_eq_Policy>({}); }
+struct TArgs_timestamp_eq_timestamptz_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_textcat() { return &GenericExec<TPgDirectFunc<&textcat>, true, false, TArgs_textcat_Policy>; }
-struct TArgs_texteq_Policy {
+TExecFunc arrow_timestamp_eq_timestamptz() { return TGenericExec<TPgDirectFunc<&timestamp_eq_timestamptz>, true, true, TArgs_timestamp_eq_timestamptz_Policy>({}); }
+struct TArgs_timestamp_finite_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_texteq() { return &GenericExec<TPgDirectFunc<&texteq>, true, true, TArgs_texteq_Policy>; }
-struct TArgs_texteqname_Policy {
+TExecFunc arrow_timestamp_finite() { return TGenericExec<TPgDirectFunc<&timestamp_finite>, true, true, TArgs_timestamp_finite_Policy>({}); }
+struct TArgs_timestamp_ge_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_texteqname() { return &GenericExec<TPgDirectFunc<&texteqname>, true, true, TArgs_texteqname_Policy>; }
-struct TArgs_textgename_Policy {
+TExecFunc arrow_timestamp_ge() { return TGenericExec<TPgDirectFunc<&timestamp_ge>, true, true, TArgs_timestamp_ge_Policy>({}); }
+struct TArgs_timestamp_ge_timestamptz_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_textgename() { return &GenericExec<TPgDirectFunc<&textgename>, true, true, TArgs_textgename_Policy>; }
-struct TArgs_textgtname_Policy {
+TExecFunc arrow_timestamp_ge_timestamptz() { return TGenericExec<TPgDirectFunc<&timestamp_ge_timestamptz>, true, true, TArgs_timestamp_ge_timestamptz_Policy>({}); }
+struct TArgs_timestamp_gt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_textgtname() { return &GenericExec<TPgDirectFunc<&textgtname>, true, true, TArgs_textgtname_Policy>; }
-struct TArgs_texticregexeq_Policy {
+TExecFunc arrow_timestamp_gt() { return TGenericExec<TPgDirectFunc<&timestamp_gt>, true, true, TArgs_timestamp_gt_Policy>({}); }
+struct TArgs_timestamp_gt_timestamptz_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_texticregexeq() { return &GenericExec<TPgDirectFunc<&texticregexeq>, true, true, TArgs_texticregexeq_Policy>; }
-struct TArgs_texticregexne_Policy {
+TExecFunc arrow_timestamp_gt_timestamptz() { return TGenericExec<TPgDirectFunc<&timestamp_gt_timestamptz>, true, true, TArgs_timestamp_gt_timestamptz_Policy>({}); }
+struct TArgs_timestamp_hash_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_texticregexne() { return &GenericExec<TPgDirectFunc<&texticregexne>, true, true, TArgs_texticregexne_Policy>; }
-struct TArgs_textin_Policy {
+TExecFunc arrow_timestamp_hash() { return TGenericExec<TPgDirectFunc<&timestamp_hash>, true, true, TArgs_timestamp_hash_Policy>({}); }
+struct TArgs_timestamp_hash_extended_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_textin() { return &GenericExec<TPgDirectFunc<&textin>, true, false, TArgs_textin_Policy>; }
-struct TArgs_textlen_Policy {
+TExecFunc arrow_timestamp_hash_extended() { return TGenericExec<TPgDirectFunc<&timestamp_hash_extended>, true, true, TArgs_timestamp_hash_extended_Policy>({}); }
+struct TArgs_timestamp_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_textlen() { return &GenericExec<TPgDirectFunc<&textlen>, true, true, TArgs_textlen_Policy>; }
-struct TArgs_textlename_Policy {
+TExecFunc arrow_timestamp_in() { return TGenericExec<TPgDirectFunc<&timestamp_in>, true, true, TArgs_timestamp_in_Policy>({}); }
+struct TArgs_timestamp_izone_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_textlename() { return &GenericExec<TPgDirectFunc<&textlename>, true, true, TArgs_textlename_Policy>; }
-struct TArgs_textltname_Policy {
+TExecFunc arrow_timestamp_izone() { return TGenericExec<TPgDirectFunc<&timestamp_izone>, true, true, TArgs_timestamp_izone_Policy>({}); }
+struct TArgs_timestamp_larger_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_textltname() { return &GenericExec<TPgDirectFunc<&textltname>, true, true, TArgs_textltname_Policy>; }
-struct TArgs_textne_Policy {
+TExecFunc arrow_timestamp_larger() { return TGenericExec<TPgDirectFunc<&timestamp_larger>, true, true, TArgs_timestamp_larger_Policy>({}); }
+struct TArgs_timestamp_le_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_textne() { return &GenericExec<TPgDirectFunc<&textne>, true, true, TArgs_textne_Policy>; }
-struct TArgs_textnename_Policy {
+TExecFunc arrow_timestamp_le() { return TGenericExec<TPgDirectFunc<&timestamp_le>, true, true, TArgs_timestamp_le_Policy>({}); }
+struct TArgs_timestamp_le_timestamptz_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_textnename() { return &GenericExec<TPgDirectFunc<&textnename>, true, true, TArgs_textnename_Policy>; }
-struct TArgs_textoctetlen_Policy {
+TExecFunc arrow_timestamp_le_timestamptz() { return TGenericExec<TPgDirectFunc<&timestamp_le_timestamptz>, true, true, TArgs_timestamp_le_timestamptz_Policy>({}); }
+struct TArgs_timestamp_lt_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_textoctetlen() { return &GenericExec<TPgDirectFunc<&textoctetlen>, true, true, TArgs_textoctetlen_Policy>; }
-struct TArgs_textout_Policy {
+TExecFunc arrow_timestamp_lt() { return TGenericExec<TPgDirectFunc<&timestamp_lt>, true, true, TArgs_timestamp_lt_Policy>({}); }
+struct TArgs_timestamp_lt_timestamptz_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_textout() { return &GenericExec<TPgDirectFunc<&textout>, true, false, TArgs_textout_Policy>; }
-struct TArgs_textoverlay_Policy {
+TExecFunc arrow_timestamp_lt_timestamptz() { return TGenericExec<TPgDirectFunc<&timestamp_lt_timestamptz>, true, true, TArgs_timestamp_lt_timestamptz_Policy>({}); }
+struct TArgs_timestamp_mi_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,false,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_textoverlay() { return &GenericExec<TPgDirectFunc<&textoverlay>, true, false, TArgs_textoverlay_Policy>; }
-struct TArgs_textoverlay_no_len_Policy {
+TExecFunc arrow_timestamp_mi() { return TGenericExec<TPgDirectFunc<&timestamp_mi>, true, false, TArgs_timestamp_mi_Policy>({}); }
+struct TArgs_timestamp_mi_interval_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_textoverlay_no_len() { return &GenericExec<TPgDirectFunc<&textoverlay_no_len>, true, false, TArgs_textoverlay_no_len_Policy>; }
-struct TArgs_textpos_Policy {
+TExecFunc arrow_timestamp_mi_interval() { return TGenericExec<TPgDirectFunc<&timestamp_mi_interval>, true, true, TArgs_timestamp_mi_interval_Policy>({}); }
+struct TArgs_timestamp_ne_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+};
+TExecFunc arrow_timestamp_ne() { return TGenericExec<TPgDirectFunc<&timestamp_ne>, true, true, TArgs_timestamp_ne_Policy>({}); }
+struct TArgs_timestamp_ne_timestamptz_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_textpos() { return &GenericExec<TPgDirectFunc<&textpos>, true, true, TArgs_textpos_Policy>; }
-struct TArgs_textrecv_Policy {
+TExecFunc arrow_timestamp_ne_timestamptz() { return TGenericExec<TPgDirectFunc<&timestamp_ne_timestamptz>, true, true, TArgs_timestamp_ne_timestamptz_Policy>({}); }
+struct TArgs_timestamp_out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_textrecv() { return &GenericExec<TPgDirectFunc<&textrecv>, true, false, TArgs_textrecv_Policy>; }
-struct TArgs_textregexeq_Policy {
+TExecFunc arrow_timestamp_out() { return TGenericExec<TPgDirectFunc<&timestamp_out>, true, false, TArgs_timestamp_out_Policy>({}); }
+struct TArgs_timestamp_part_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_textregexeq() { return &GenericExec<TPgDirectFunc<&textregexeq>, true, true, TArgs_textregexeq_Policy>; }
-struct TArgs_textregexne_Policy {
+TExecFunc arrow_timestamp_part() { return TGenericExec<TPgDirectFunc<&timestamp_part>, true, true, TArgs_timestamp_part_Policy>({}); }
+struct TArgs_timestamp_pl_interval_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_textregexne() { return &GenericExec<TPgDirectFunc<&textregexne>, true, true, TArgs_textregexne_Policy>; }
-struct TArgs_textregexreplace_Policy {
+TExecFunc arrow_timestamp_pl_interval() { return TGenericExec<TPgDirectFunc<&timestamp_pl_interval>, true, true, TArgs_timestamp_pl_interval_Policy>({}); }
+struct TArgs_timestamp_recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,false};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_textregexreplace() { return &GenericExec<TPgDirectFunc<&textregexreplace>, true, false, TArgs_textregexreplace_Policy>; }
-struct TArgs_textregexreplace_noopt_Policy {
+TExecFunc arrow_timestamp_recv() { return TGenericExec<TPgDirectFunc<&timestamp_recv>, true, true, TArgs_timestamp_recv_Policy>({}); }
+struct TArgs_timestamp_scale_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_textregexreplace_noopt() { return &GenericExec<TPgDirectFunc<&textregexreplace_noopt>, true, false, TArgs_textregexreplace_noopt_Policy>; }
-struct TArgs_textregexsubstr_Policy {
+TExecFunc arrow_timestamp_scale() { return TGenericExec<TPgDirectFunc<&timestamp_scale>, true, true, TArgs_timestamp_scale_Policy>({}); }
+struct TArgs_timestamp_send_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_textregexsubstr() { return &GenericExec<TPgDirectFunc<&textregexsubstr>, true, false, TArgs_textregexsubstr_Policy>; }
-struct TArgs_textsend_Policy {
+TExecFunc arrow_timestamp_send() { return TGenericExec<TPgDirectFunc<&timestamp_send>, true, false, TArgs_timestamp_send_Policy>({}); }
+struct TArgs_timestamp_smaller_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_textsend() { return &GenericExec<TPgDirectFunc<&textsend>, true, false, TArgs_textsend_Policy>; }
-struct TArgs_texttoxml_Policy {
+TExecFunc arrow_timestamp_smaller() { return TGenericExec<TPgDirectFunc<&timestamp_smaller>, true, true, TArgs_timestamp_smaller_Policy>({}); }
+struct TArgs_timestamp_sortsupport_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_texttoxml() { return &GenericExec<TPgDirectFunc<&texttoxml>, true, false, TArgs_texttoxml_Policy>; }
-struct TArgs_to_hex32_Policy {
+TExecFunc arrow_timestamp_sortsupport() { return TGenericExec<TPgDirectFunc<&timestamp_sortsupport>, true, true, TArgs_timestamp_sortsupport_Policy>({}); }
+struct TArgs_timestamp_support_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_to_hex32() { return &GenericExec<TPgDirectFunc<&to_hex32>, true, false, TArgs_to_hex32_Policy>; }
-struct TArgs_to_hex64_Policy {
+TExecFunc arrow_timestamp_support() { return TGenericExec<TPgDirectFunc<&timestamp_support>, true, true, TArgs_timestamp_support_Policy>({}); }
+struct TArgs_timestamp_timestamptz_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_to_hex64() { return &GenericExec<TPgDirectFunc<&to_hex64>, true, false, TArgs_to_hex64_Policy>; }
-struct TArgs_to_regclass_Policy {
+TExecFunc arrow_timestamp_timestamptz() { return TGenericExec<TPgDirectFunc<&timestamp_timestamptz>, true, true, TArgs_timestamp_timestamptz_Policy>({}); }
+struct TArgs_timestamp_to_char_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_to_regclass() { return &GenericExec<TPgDirectFunc<&to_regclass>, true, true, TArgs_to_regclass_Policy>; }
-struct TArgs_to_regcollation_Policy {
+TExecFunc arrow_timestamp_to_char() { return TGenericExec<TPgDirectFunc<&timestamp_to_char>, true, false, TArgs_timestamp_to_char_Policy>({}); }
+struct TArgs_timestamp_trunc_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_to_regcollation() { return &GenericExec<TPgDirectFunc<&to_regcollation>, true, true, TArgs_to_regcollation_Policy>; }
-struct TArgs_to_regnamespace_Policy {
+TExecFunc arrow_timestamp_trunc() { return TGenericExec<TPgDirectFunc<&timestamp_trunc>, true, true, TArgs_timestamp_trunc_Policy>({}); }
+struct TArgs_timestamp_zone_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_to_regnamespace() { return &GenericExec<TPgDirectFunc<&to_regnamespace>, true, true, TArgs_to_regnamespace_Policy>; }
-struct TArgs_to_regoper_Policy {
+TExecFunc arrow_timestamp_zone() { return TGenericExec<TPgDirectFunc<&timestamp_zone>, true, true, TArgs_timestamp_zone_Policy>({}); }
+struct TArgs_timestamptypmodin_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_to_regoper() { return &GenericExec<TPgDirectFunc<&to_regoper>, true, true, TArgs_to_regoper_Policy>; }
-struct TArgs_to_regoperator_Policy {
+TExecFunc arrow_timestamptypmodin() { return TGenericExec<TPgDirectFunc<&timestamptypmodin>, true, true, TArgs_timestamptypmodin_Policy>({}); }
+struct TArgs_timestamptypmodout_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_to_regoperator() { return &GenericExec<TPgDirectFunc<&to_regoperator>, true, true, TArgs_to_regoperator_Policy>; }
-struct TArgs_to_regproc_Policy {
+TExecFunc arrow_timestamptypmodout() { return TGenericExec<TPgDirectFunc<&timestamptypmodout>, true, false, TArgs_timestamptypmodout_Policy>({}); }
+struct TArgs_timestamptz_age_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_to_regproc() { return &GenericExec<TPgDirectFunc<&to_regproc>, true, true, TArgs_to_regproc_Policy>; }
-struct TArgs_to_regprocedure_Policy {
+TExecFunc arrow_timestamptz_age() { return TGenericExec<TPgDirectFunc<&timestamptz_age>, true, false, TArgs_timestamptz_age_Policy>({}); }
+struct TArgs_timestamptz_bin_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_to_regprocedure() { return &GenericExec<TPgDirectFunc<&to_regprocedure>, true, true, TArgs_to_regprocedure_Policy>; }
-struct TArgs_to_regrole_Policy {
+TExecFunc arrow_timestamptz_bin() { return TGenericExec<TPgDirectFunc<&timestamptz_bin>, true, true, TArgs_timestamptz_bin_Policy>({}); }
+struct TArgs_timestamptz_cmp_timestamp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_to_regrole() { return &GenericExec<TPgDirectFunc<&to_regrole>, true, true, TArgs_to_regrole_Policy>; }
-struct TArgs_to_regtype_Policy {
+TExecFunc arrow_timestamptz_cmp_timestamp() { return TGenericExec<TPgDirectFunc<&timestamptz_cmp_timestamp>, true, true, TArgs_timestamptz_cmp_timestamp_Policy>({}); }
+struct TArgs_timestamptz_eq_timestamp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_to_regtype() { return &GenericExec<TPgDirectFunc<&to_regtype>, true, true, TArgs_to_regtype_Policy>; }
-struct TArgs_ts_rank_tt_Policy {
+TExecFunc arrow_timestamptz_eq_timestamp() { return TGenericExec<TPgDirectFunc<&timestamptz_eq_timestamp>, true, true, TArgs_timestamptz_eq_timestamp_Policy>({}); }
+struct TArgs_timestamptz_ge_timestamp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_ts_rank_tt() { return &GenericExec<TPgDirectFunc<&ts_rank_tt>, true, true, TArgs_ts_rank_tt_Policy>; }
-struct TArgs_ts_rank_ttf_Policy {
+TExecFunc arrow_timestamptz_ge_timestamp() { return TGenericExec<TPgDirectFunc<&timestamptz_ge_timestamp>, true, true, TArgs_timestamptz_ge_timestamp_Policy>({}); }
+struct TArgs_timestamptz_gt_timestamp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_ts_rank_ttf() { return &GenericExec<TPgDirectFunc<&ts_rank_ttf>, true, true, TArgs_ts_rank_ttf_Policy>; }
-struct TArgs_ts_rank_wtt_Policy {
+TExecFunc arrow_timestamptz_gt_timestamp() { return TGenericExec<TPgDirectFunc<&timestamptz_gt_timestamp>, true, true, TArgs_timestamptz_gt_timestamp_Policy>({}); }
+struct TArgs_timestamptz_in_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
 };
-TExecFunc arrow_ts_rank_wtt() { return &GenericExec<TPgDirectFunc<&ts_rank_wtt>, true, true, TArgs_ts_rank_wtt_Policy>; }
-struct TArgs_ts_rank_wttf_Policy {
+TExecFunc arrow_timestamptz_in() { return TGenericExec<TPgDirectFunc<&timestamptz_in>, true, true, TArgs_timestamptz_in_Policy>({}); }
+struct TArgs_timestamptz_izone_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_ts_rank_wttf() { return &GenericExec<TPgDirectFunc<&ts_rank_wttf>, true, true, TArgs_ts_rank_wttf_Policy>; }
-struct TArgs_ts_rankcd_tt_Policy {
+TExecFunc arrow_timestamptz_izone() { return TGenericExec<TPgDirectFunc<&timestamptz_izone>, true, true, TArgs_timestamptz_izone_Policy>({}); }
+struct TArgs_timestamptz_le_timestamp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_ts_rankcd_tt() { return &GenericExec<TPgDirectFunc<&ts_rankcd_tt>, true, true, TArgs_ts_rankcd_tt_Policy>; }
-struct TArgs_ts_rankcd_ttf_Policy {
+TExecFunc arrow_timestamptz_le_timestamp() { return TGenericExec<TPgDirectFunc<&timestamptz_le_timestamp>, true, true, TArgs_timestamptz_le_timestamp_Policy>({}); }
+struct TArgs_timestamptz_lt_timestamp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_ts_rankcd_ttf() { return &GenericExec<TPgDirectFunc<&ts_rankcd_ttf>, true, true, TArgs_ts_rankcd_ttf_Policy>; }
-struct TArgs_ts_rankcd_wtt_Policy {
+TExecFunc arrow_timestamptz_lt_timestamp() { return TGenericExec<TPgDirectFunc<&timestamptz_lt_timestamp>, true, true, TArgs_timestamptz_lt_timestamp_Policy>({}); }
+struct TArgs_timestamptz_mi_interval_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_ts_rankcd_wtt() { return &GenericExec<TPgDirectFunc<&ts_rankcd_wtt>, true, true, TArgs_ts_rankcd_wtt_Policy>; }
-struct TArgs_ts_rankcd_wttf_Policy {
+TExecFunc arrow_timestamptz_mi_interval() { return TGenericExec<TPgDirectFunc<&timestamptz_mi_interval>, true, true, TArgs_timestamptz_mi_interval_Policy>({}); }
+struct TArgs_timestamptz_ne_timestamp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
 };
-TExecFunc arrow_ts_rankcd_wttf() { return &GenericExec<TPgDirectFunc<&ts_rankcd_wttf>, true, true, TArgs_ts_rankcd_wttf_Policy>; }
-struct TArgs_ts_typanalyze_Policy {
+TExecFunc arrow_timestamptz_ne_timestamp() { return TGenericExec<TPgDirectFunc<&timestamptz_ne_timestamp>, true, true, TArgs_timestamptz_ne_timestamp_Policy>({}); }
+struct TArgs_timestamptz_out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_ts_typanalyze() { return &GenericExec<TPgDirectFunc<&ts_typanalyze>, true, true, TArgs_ts_typanalyze_Policy>; }
-struct TArgs_tsm_bernoulli_handler_Policy {
+TExecFunc arrow_timestamptz_out() { return TGenericExec<TPgDirectFunc<&timestamptz_out>, true, false, TArgs_timestamptz_out_Policy>({}); }
+struct TArgs_timestamptz_part_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_tsm_bernoulli_handler() { return &GenericExec<TPgDirectFunc<&tsm_bernoulli_handler>, true, true, TArgs_tsm_bernoulli_handler_Policy>; }
-struct TArgs_tsm_system_handler_Policy {
+TExecFunc arrow_timestamptz_part() { return TGenericExec<TPgDirectFunc<&timestamptz_part>, true, true, TArgs_timestamptz_part_Policy>({}); }
+struct TArgs_timestamptz_pl_interval_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+};
+TExecFunc arrow_timestamptz_pl_interval() { return TGenericExec<TPgDirectFunc<&timestamptz_pl_interval>, true, true, TArgs_timestamptz_pl_interval_Policy>({}); }
+struct TArgs_timestamptz_recv_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
+};
+TExecFunc arrow_timestamptz_recv() { return TGenericExec<TPgDirectFunc<&timestamptz_recv>, true, true, TArgs_timestamptz_recv_Policy>({}); }
+struct TArgs_timestamptz_scale_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {true,true};
+};
+TExecFunc arrow_timestamptz_scale() { return TGenericExec<TPgDirectFunc<&timestamptz_scale>, true, true, TArgs_timestamptz_scale_Policy>({}); }
+struct TArgs_timestamptz_send_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_tsm_system_handler() { return &GenericExec<TPgDirectFunc<&tsm_system_handler>, true, true, TArgs_tsm_system_handler_Policy>; }
-struct TArgs_unicode_is_normalized_Policy {
+TExecFunc arrow_timestamptz_send() { return TGenericExec<TPgDirectFunc<&timestamptz_send>, true, false, TArgs_timestamptz_send_Policy>({}); }
+struct TArgs_timestamptz_timestamp_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_unicode_is_normalized() { return &GenericExec<TPgDirectFunc<&unicode_is_normalized>, true, true, TArgs_unicode_is_normalized_Policy>; }
-struct TArgs_unicode_normalize_func_Policy {
+TExecFunc arrow_timestamptz_timestamp() { return TGenericExec<TPgDirectFunc<&timestamptz_timestamp>, true, true, TArgs_timestamptz_timestamp_Policy>({}); }
+struct TArgs_timestamptz_to_char_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
 };
-TExecFunc arrow_unicode_normalize_func() { return &GenericExec<TPgDirectFunc<&unicode_normalize_func>, true, false, TArgs_unicode_normalize_func_Policy>; }
-struct TArgs_unique_key_recheck_Policy {
+TExecFunc arrow_timestamptz_to_char() { return TGenericExec<TPgDirectFunc<&timestamptz_to_char>, true, false, TArgs_timestamptz_to_char_Policy>({}); }
+struct TArgs_timestamptz_trunc_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 0> IsFixedArg = {};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_unique_key_recheck() { return &GenericExec<TPgDirectFunc<&unique_key_recheck>, true, true, TArgs_unique_key_recheck_Policy>; }
-struct TArgs_unistr_Policy {
+TExecFunc arrow_timestamptz_trunc() { return TGenericExec<TPgDirectFunc<&timestamptz_trunc>, true, true, TArgs_timestamptz_trunc_Policy>({}); }
+struct TArgs_timestamptz_trunc_zone_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,false};
 };
-TExecFunc arrow_unistr() { return &GenericExec<TPgDirectFunc<&unistr>, true, false, TArgs_unistr_Policy>; }
-struct TArgs_unknownin_Policy {
+TExecFunc arrow_timestamptz_trunc_zone() { return TGenericExec<TPgDirectFunc<&timestamptz_trunc_zone>, true, true, TArgs_timestamptz_trunc_zone_Policy>({}); }
+struct TArgs_timestamptz_zone_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {false};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
 };
-TExecFunc arrow_unknownin() { return &GenericExec<TPgDirectFunc<&unknownin>, true, false, TArgs_unknownin_Policy>; }
-struct TArgs_unknownout_Policy {
+TExecFunc arrow_timestamptz_zone() { return TGenericExec<TPgDirectFunc<&timestamptz_zone>, true, true, TArgs_timestamptz_zone_Policy>({}); }
+struct TArgs_timestamptztypmodin_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_unknownout() { return &GenericExec<TPgDirectFunc<&unknownout>, true, false, TArgs_unknownout_Policy>; }
-struct TArgs_unknownrecv_Policy {
+TExecFunc arrow_timestamptztypmodin() { return TGenericExec<TPgDirectFunc<&timestamptztypmodin>, true, true, TArgs_timestamptztypmodin_Policy>({}); }
+struct TArgs_timestamptztypmodout_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {true};
 };
-TExecFunc arrow_unknownrecv() { return &GenericExec<TPgDirectFunc<&unknownrecv>, true, false, TArgs_unknownrecv_Policy>; }
-struct TArgs_unknownsend_Policy {
+TExecFunc arrow_timestamptztypmodout() { return TGenericExec<TPgDirectFunc<&timestamptztypmodout>, true, false, TArgs_timestamptztypmodout_Policy>({}); }
+struct TArgs_to_ascii_default_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_unknownsend() { return &GenericExec<TPgDirectFunc<&unknownsend>, true, false, TArgs_unknownsend_Policy>; }
-struct TArgs_width_bucket_float8_Policy {
+TExecFunc arrow_to_ascii_default() { return TGenericExec<TPgDirectFunc<&to_ascii_default>, true, false, TArgs_to_ascii_default_Policy>({}); }
+struct TArgs_to_ascii_enc_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+    static constexpr std::array<bool, 2> IsFixedArg = {false,true};
+};
+TExecFunc arrow_to_ascii_enc() { return TGenericExec<TPgDirectFunc<&to_ascii_enc>, true, false, TArgs_to_ascii_enc_Policy>({}); }
+struct TArgs_to_ascii_encname_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_width_bucket_float8() { return &GenericExec<TPgDirectFunc<&width_bucket_float8>, true, true, TArgs_width_bucket_float8_Policy>; }
-struct TArgs_xml_in_Policy {
+TExecFunc arrow_to_ascii_encname() { return TGenericExec<TPgDirectFunc<&to_ascii_encname>, true, false, TArgs_to_ascii_encname_Policy>({}); }
+struct TArgs_to_date_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+};
+TExecFunc arrow_to_date() { return TGenericExec<TPgDirectFunc<&to_date>, true, true, TArgs_to_date_Policy>({}); }
+struct TArgs_to_regclass_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_xml_in() { return &GenericExec<TPgDirectFunc<&xml_in>, true, false, TArgs_xml_in_Policy>; }
-struct TArgs_xml_is_well_formed_Policy {
+TExecFunc arrow_to_regclass() { return TGenericExec<TPgDirectFunc<&to_regclass>, true, true, TArgs_to_regclass_Policy>({}); }
+struct TArgs_to_regcollation_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_xml_is_well_formed() { return &GenericExec<TPgDirectFunc<&xml_is_well_formed>, true, true, TArgs_xml_is_well_formed_Policy>; }
-struct TArgs_xml_is_well_formed_content_Policy {
+TExecFunc arrow_to_regcollation() { return TGenericExec<TPgDirectFunc<&to_regcollation>, true, true, TArgs_to_regcollation_Policy>({}); }
+struct TArgs_to_regnamespace_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_xml_is_well_formed_content() { return &GenericExec<TPgDirectFunc<&xml_is_well_formed_content>, true, true, TArgs_xml_is_well_formed_content_Policy>; }
-struct TArgs_xml_is_well_formed_document_Policy {
+TExecFunc arrow_to_regnamespace() { return TGenericExec<TPgDirectFunc<&to_regnamespace>, true, true, TArgs_to_regnamespace_Policy>({}); }
+struct TArgs_to_regoper_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_xml_is_well_formed_document() { return &GenericExec<TPgDirectFunc<&xml_is_well_formed_document>, true, true, TArgs_xml_is_well_formed_document_Policy>; }
-struct TArgs_xml_out_Policy {
+TExecFunc arrow_to_regoper() { return TGenericExec<TPgDirectFunc<&to_regoper>, true, true, TArgs_to_regoper_Policy>({}); }
+struct TArgs_to_regoperator_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_xml_out() { return &GenericExec<TPgDirectFunc<&xml_out>, true, false, TArgs_xml_out_Policy>; }
-struct TArgs_xml_recv_Policy {
+TExecFunc arrow_to_regoperator() { return TGenericExec<TPgDirectFunc<&to_regoperator>, true, true, TArgs_to_regoperator_Policy>({}); }
+struct TArgs_to_regproc_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 1> IsFixedArg = {true};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_xml_recv() { return &GenericExec<TPgDirectFunc<&xml_recv>, true, false, TArgs_xml_recv_Policy>; }
-struct TArgs_xml_send_Policy {
+TExecFunc arrow_to_regproc() { return TGenericExec<TPgDirectFunc<&to_regproc>, true, true, TArgs_to_regproc_Policy>({}); }
+struct TArgs_to_regprocedure_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_xml_send() { return &GenericExec<TPgDirectFunc<&xml_send>, true, false, TArgs_xml_send_Policy>; }
-struct TArgs_xmlcomment_Policy {
+TExecFunc arrow_to_regprocedure() { return TGenericExec<TPgDirectFunc<&to_regprocedure>, true, true, TArgs_to_regprocedure_Policy>({}); }
+struct TArgs_to_regrole_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_xmlcomment() { return &GenericExec<TPgDirectFunc<&xmlcomment>, true, false, TArgs_xmlcomment_Policy>; }
-struct TArgs_xmlconcat2_Policy {
+TExecFunc arrow_to_regrole() { return TGenericExec<TPgDirectFunc<&to_regrole>, true, true, TArgs_to_regrole_Policy>({}); }
+struct TArgs_to_regtype_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_to_regtype() { return TGenericExec<TPgDirectFunc<&to_regtype>, true, true, TArgs_to_regtype_Policy>({}); }
+struct TArgs_to_timestamp_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_xmlconcat2() { return &GenericExec<TPgDirectFunc<&xmlconcat2>, false, false, TArgs_xmlconcat2_Policy>; }
-struct TArgs_xmlexists_Policy {
+TExecFunc arrow_to_timestamp() { return TGenericExec<TPgDirectFunc<&to_timestamp>, true, true, TArgs_to_timestamp_Policy>({}); }
+struct TArgs_ts_lexize_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 2> IsFixedArg = {true,false};
+};
+TExecFunc arrow_ts_lexize() { return TGenericExec<TPgDirectFunc<&ts_lexize>, true, false, TArgs_ts_lexize_Policy>({}); }
+struct TArgs_ts_typanalyze_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_ts_typanalyze() { return TGenericExec<TPgDirectFunc<&ts_typanalyze>, true, true, TArgs_ts_typanalyze_Policy>({}); }
+struct TArgs_tsm_bernoulli_handler_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_tsm_bernoulli_handler() { return TGenericExec<TPgDirectFunc<&tsm_bernoulli_handler>, true, true, TArgs_tsm_bernoulli_handler_Policy>({}); }
+struct TArgs_tsmatchjoinsel_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 5> IsFixedArg = {true,true,true,true,true};
+};
+TExecFunc arrow_tsmatchjoinsel() { return TGenericExec<TPgDirectFunc<&tsmatchjoinsel>, true, true, TArgs_tsmatchjoinsel_Policy>({}); }
+struct TArgs_tsmatchsel_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 4> IsFixedArg = {true,true,true,true};
+};
+TExecFunc arrow_tsmatchsel() { return TGenericExec<TPgDirectFunc<&tsmatchsel>, true, true, TArgs_tsmatchsel_Policy>({}); }
+struct TArgs_tsquery_rewrite_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+};
+TExecFunc arrow_tsquery_rewrite() { return TGenericExec<TPgDirectFunc<&tsquery_rewrite>, true, false, TArgs_tsquery_rewrite_Policy>({}); }
+struct TArgs_tsquery_rewrite_query_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 2> IsFixedArg = {false,false};
 };
-TExecFunc arrow_xmlexists() { return &GenericExec<TPgDirectFunc<&xmlexists>, true, true, TArgs_xmlexists_Policy>; }
-struct TArgs_xmltotext_Policy {
+TExecFunc arrow_tsquery_rewrite_query() { return TGenericExec<TPgDirectFunc<&tsquery_rewrite_query>, true, false, TArgs_tsquery_rewrite_query_Policy>({}); }
+struct TArgs_varbit_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+};
+TExecFunc arrow_varbit() { return TGenericExec<TPgDirectFunc<&varbit>, true, false, TArgs_varbit_Policy>({}); }
+struct TArgs_varbit_in_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 3> IsFixedArg = {false,true,true};
+};
+TExecFunc arrow_varbit_in() { return TGenericExec<TPgDirectFunc<&varbit_in>, true, false, TArgs_varbit_in_Policy>({}); }
+struct TArgs_varbit_out_Policy {
     static constexpr bool VarArgs = false;
     static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_xmltotext() { return &GenericExec<TPgDirectFunc<&xmltotext>, true, false, TArgs_xmltotext_Policy>; }
-struct TArgs_xmlvalidate_Policy {
+TExecFunc arrow_varbit_out() { return TGenericExec<TPgDirectFunc<&varbit_out>, true, false, TArgs_varbit_out_Policy>({}); }
+struct TArgs_varbit_recv_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 2> IsFixedArg = {false,false};
+    static constexpr std::array<bool, 3> IsFixedArg = {true,true,true};
 };
-TExecFunc arrow_xmlvalidate() { return &GenericExec<TPgDirectFunc<&xmlvalidate>, true, true, TArgs_xmlvalidate_Policy>; }
-struct TArgs_xpath_Policy {
+TExecFunc arrow_varbit_recv() { return TGenericExec<TPgDirectFunc<&varbit_recv>, true, false, TArgs_varbit_recv_Policy>({}); }
+struct TArgs_varbit_send_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
 };
-TExecFunc arrow_xpath() { return &GenericExec<TPgDirectFunc<&xpath>, true, false, TArgs_xpath_Policy>; }
-struct TArgs_xpath_exists_Policy {
+TExecFunc arrow_varbit_send() { return TGenericExec<TPgDirectFunc<&varbit_send>, true, false, TArgs_varbit_send_Policy>({}); }
+struct TArgs_varbit_support_Policy {
     static constexpr bool VarArgs = false;
-    static constexpr std::array<bool, 3> IsFixedArg = {false,false,false};
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_varbit_support() { return TGenericExec<TPgDirectFunc<&varbit_support>, true, true, TArgs_varbit_support_Policy>({}); }
+struct TArgs_varbittypmodin_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {false};
+};
+TExecFunc arrow_varbittypmodin() { return TGenericExec<TPgDirectFunc<&varbittypmodin>, true, true, TArgs_varbittypmodin_Policy>({}); }
+struct TArgs_varbittypmodout_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 1> IsFixedArg = {true};
+};
+TExecFunc arrow_varbittypmodout() { return TGenericExec<TPgDirectFunc<&varbittypmodout>, true, false, TArgs_varbittypmodout_Policy>({}); }
+struct TArgs_width_bucket_numeric_Policy {
+    static constexpr bool VarArgs = false;
+    static constexpr std::array<bool, 4> IsFixedArg = {false,false,false,true};
 };
-TExecFunc arrow_xpath_exists() { return &GenericExec<TPgDirectFunc<&xpath_exists>, true, true, TArgs_xpath_exists_Policy>; }
+TExecFunc arrow_width_bucket_numeric() { return TGenericExec<TPgDirectFunc<&width_bucket_numeric>, true, true, TArgs_width_bucket_numeric_Policy>({}); }
diff --git a/ydb/library/yql/parser/pg_wrapper/pg_kernels.slow.0.inc b/ydb/library/yql/parser/pg_wrapper/pg_kernels.slow.0.inc
new file mode 100644
index 00000000000..c039f8b7c44
--- /dev/null
+++ b/ydb/library/yql/parser/pg_wrapper/pg_kernels.slow.0.inc
@@ -0,0 +1,487 @@
+TExecFunc arrow_PG_char_to_encoding() { return MakeIndirectExec<true, true>(&PG_char_to_encoding); }
+TExecFunc arrow_PG_encoding_to_char() { return MakeIndirectExec<true, false>(&PG_encoding_to_char); }
+TExecFunc arrow_array_subscript_handler() { return MakeIndirectExec<true, true>(&array_subscript_handler); }
+TExecFunc arrow_array_to_json() { return MakeIndirectExec<true, false>(&array_to_json); }
+TExecFunc arrow_array_to_json_pretty() { return MakeIndirectExec<true, false>(&array_to_json_pretty); }
+TExecFunc arrow_ascii() { return MakeIndirectExec<true, true>(&ascii); }
+TExecFunc arrow_be_lo_close() { return MakeIndirectExec<true, true>(&be_lo_close); }
+TExecFunc arrow_be_lo_creat() { return MakeIndirectExec<true, true>(&be_lo_creat); }
+TExecFunc arrow_be_lo_create() { return MakeIndirectExec<true, true>(&be_lo_create); }
+TExecFunc arrow_be_lo_export() { return MakeIndirectExec<true, true>(&be_lo_export); }
+TExecFunc arrow_be_lo_from_bytea() { return MakeIndirectExec<true, true>(&be_lo_from_bytea); }
+TExecFunc arrow_be_lo_get() { return MakeIndirectExec<true, false>(&be_lo_get); }
+TExecFunc arrow_be_lo_get_fragment() { return MakeIndirectExec<true, false>(&be_lo_get_fragment); }
+TExecFunc arrow_be_lo_import() { return MakeIndirectExec<true, true>(&be_lo_import); }
+TExecFunc arrow_be_lo_import_with_oid() { return MakeIndirectExec<true, true>(&be_lo_import_with_oid); }
+TExecFunc arrow_be_lo_lseek() { return MakeIndirectExec<true, true>(&be_lo_lseek); }
+TExecFunc arrow_be_lo_lseek64() { return MakeIndirectExec<true, true>(&be_lo_lseek64); }
+TExecFunc arrow_be_lo_open() { return MakeIndirectExec<true, true>(&be_lo_open); }
+TExecFunc arrow_be_lo_put() { return MakeIndirectExec<true, true>(&be_lo_put); }
+TExecFunc arrow_be_lo_tell() { return MakeIndirectExec<true, true>(&be_lo_tell); }
+TExecFunc arrow_be_lo_tell64() { return MakeIndirectExec<true, true>(&be_lo_tell64); }
+TExecFunc arrow_be_lo_truncate() { return MakeIndirectExec<true, true>(&be_lo_truncate); }
+TExecFunc arrow_be_lo_truncate64() { return MakeIndirectExec<true, true>(&be_lo_truncate64); }
+TExecFunc arrow_be_lo_unlink() { return MakeIndirectExec<true, true>(&be_lo_unlink); }
+TExecFunc arrow_be_loread() { return MakeIndirectExec<true, false>(&be_loread); }
+TExecFunc arrow_be_lowrite() { return MakeIndirectExec<true, true>(&be_lowrite); }
+TExecFunc arrow_bool_accum() { return MakeIndirectExec<false, true>(&bool_accum); }
+TExecFunc arrow_bool_accum_inv() { return MakeIndirectExec<false, true>(&bool_accum_inv); }
+TExecFunc arrow_bool_alltrue() { return MakeIndirectExec<true, true>(&bool_alltrue); }
+TExecFunc arrow_bool_anytrue() { return MakeIndirectExec<true, true>(&bool_anytrue); }
+TExecFunc arrow_booland_statefunc() { return MakeIndirectExec<true, true>(&booland_statefunc); }
+TExecFunc arrow_booleq() { return MakeIndirectExec<true, true>(&booleq); }
+TExecFunc arrow_boolge() { return MakeIndirectExec<true, true>(&boolge); }
+TExecFunc arrow_boolgt() { return MakeIndirectExec<true, true>(&boolgt); }
+TExecFunc arrow_boolin() { return MakeIndirectExec<true, true>(&boolin); }
+TExecFunc arrow_boolle() { return MakeIndirectExec<true, true>(&boolle); }
+TExecFunc arrow_boollt() { return MakeIndirectExec<true, true>(&boollt); }
+TExecFunc arrow_boolne() { return MakeIndirectExec<true, true>(&boolne); }
+TExecFunc arrow_boolor_statefunc() { return MakeIndirectExec<true, true>(&boolor_statefunc); }
+TExecFunc arrow_boolout() { return MakeIndirectExec<true, false>(&boolout); }
+TExecFunc arrow_boolrecv() { return MakeIndirectExec<true, true>(&boolrecv); }
+TExecFunc arrow_boolsend() { return MakeIndirectExec<true, false>(&boolsend); }
+TExecFunc arrow_booltext() { return MakeIndirectExec<true, false>(&booltext); }
+TExecFunc arrow_brin_desummarize_range() { return MakeIndirectExec<true, true>(&brin_desummarize_range); }
+TExecFunc arrow_brin_minmax_multi_add_value() { return MakeIndirectExec<true, true>(&brin_minmax_multi_add_value); }
+TExecFunc arrow_brin_minmax_multi_consistent() { return MakeIndirectExec<true, true>(&brin_minmax_multi_consistent); }
+TExecFunc arrow_brin_minmax_multi_distance_date() { return MakeIndirectExec<true, true>(&brin_minmax_multi_distance_date); }
+TExecFunc arrow_brin_minmax_multi_distance_float4() { return MakeIndirectExec<true, true>(&brin_minmax_multi_distance_float4); }
+TExecFunc arrow_brin_minmax_multi_distance_float8() { return MakeIndirectExec<true, true>(&brin_minmax_multi_distance_float8); }
+TExecFunc arrow_brin_minmax_multi_distance_inet() { return MakeIndirectExec<true, true>(&brin_minmax_multi_distance_inet); }
+TExecFunc arrow_brin_minmax_multi_distance_int2() { return MakeIndirectExec<true, true>(&brin_minmax_multi_distance_int2); }
+TExecFunc arrow_brin_minmax_multi_distance_int4() { return MakeIndirectExec<true, true>(&brin_minmax_multi_distance_int4); }
+TExecFunc arrow_brin_minmax_multi_distance_int8() { return MakeIndirectExec<true, true>(&brin_minmax_multi_distance_int8); }
+TExecFunc arrow_brin_minmax_multi_distance_interval() { return MakeIndirectExec<true, true>(&brin_minmax_multi_distance_interval); }
+TExecFunc arrow_brin_minmax_multi_distance_macaddr() { return MakeIndirectExec<true, true>(&brin_minmax_multi_distance_macaddr); }
+TExecFunc arrow_brin_minmax_multi_distance_macaddr8() { return MakeIndirectExec<true, true>(&brin_minmax_multi_distance_macaddr8); }
+TExecFunc arrow_brin_minmax_multi_distance_numeric() { return MakeIndirectExec<true, true>(&brin_minmax_multi_distance_numeric); }
+TExecFunc arrow_brin_minmax_multi_distance_pg_lsn() { return MakeIndirectExec<true, true>(&brin_minmax_multi_distance_pg_lsn); }
+TExecFunc arrow_brin_minmax_multi_distance_tid() { return MakeIndirectExec<true, true>(&brin_minmax_multi_distance_tid); }
+TExecFunc arrow_brin_minmax_multi_distance_time() { return MakeIndirectExec<true, true>(&brin_minmax_multi_distance_time); }
+TExecFunc arrow_brin_minmax_multi_distance_timestamp() { return MakeIndirectExec<true, true>(&brin_minmax_multi_distance_timestamp); }
+TExecFunc arrow_brin_minmax_multi_distance_timetz() { return MakeIndirectExec<true, true>(&brin_minmax_multi_distance_timetz); }
+TExecFunc arrow_brin_minmax_multi_distance_uuid() { return MakeIndirectExec<true, true>(&brin_minmax_multi_distance_uuid); }
+TExecFunc arrow_brin_minmax_multi_opcinfo() { return MakeIndirectExec<true, true>(&brin_minmax_multi_opcinfo); }
+TExecFunc arrow_brin_minmax_multi_options() { return MakeIndirectExec<false, true>(&brin_minmax_multi_options); }
+TExecFunc arrow_brin_minmax_multi_summary_in() { return MakeIndirectExec<true, false>(&brin_minmax_multi_summary_in); }
+TExecFunc arrow_brin_minmax_multi_summary_out() { return MakeIndirectExec<true, false>(&brin_minmax_multi_summary_out); }
+TExecFunc arrow_brin_minmax_multi_summary_recv() { return MakeIndirectExec<true, false>(&brin_minmax_multi_summary_recv); }
+TExecFunc arrow_brin_minmax_multi_summary_send() { return MakeIndirectExec<true, false>(&brin_minmax_multi_summary_send); }
+TExecFunc arrow_brin_minmax_multi_union() { return MakeIndirectExec<true, true>(&brin_minmax_multi_union); }
+TExecFunc arrow_brin_summarize_new_values() { return MakeIndirectExec<true, true>(&brin_summarize_new_values); }
+TExecFunc arrow_brin_summarize_range() { return MakeIndirectExec<true, true>(&brin_summarize_range); }
+TExecFunc arrow_brinhandler() { return MakeIndirectExec<true, true>(&brinhandler); }
+TExecFunc arrow_btboolcmp() { return MakeIndirectExec<true, true>(&btboolcmp); }
+TExecFunc arrow_btcharcmp() { return MakeIndirectExec<true, true>(&btcharcmp); }
+TExecFunc arrow_btint24cmp() { return MakeIndirectExec<true, true>(&btint24cmp); }
+TExecFunc arrow_btint28cmp() { return MakeIndirectExec<true, true>(&btint28cmp); }
+TExecFunc arrow_btint2cmp() { return MakeIndirectExec<true, true>(&btint2cmp); }
+TExecFunc arrow_btint2sortsupport() { return MakeIndirectExec<true, true>(&btint2sortsupport); }
+TExecFunc arrow_btint42cmp() { return MakeIndirectExec<true, true>(&btint42cmp); }
+TExecFunc arrow_btint48cmp() { return MakeIndirectExec<true, true>(&btint48cmp); }
+TExecFunc arrow_btint4cmp() { return MakeIndirectExec<true, true>(&btint4cmp); }
+TExecFunc arrow_btint4sortsupport() { return MakeIndirectExec<true, true>(&btint4sortsupport); }
+TExecFunc arrow_btint82cmp() { return MakeIndirectExec<true, true>(&btint82cmp); }
+TExecFunc arrow_btint84cmp() { return MakeIndirectExec<true, true>(&btint84cmp); }
+TExecFunc arrow_btint8cmp() { return MakeIndirectExec<true, true>(&btint8cmp); }
+TExecFunc arrow_btint8sortsupport() { return MakeIndirectExec<true, true>(&btint8sortsupport); }
+TExecFunc arrow_btoidcmp() { return MakeIndirectExec<true, true>(&btoidcmp); }
+TExecFunc arrow_btoidsortsupport() { return MakeIndirectExec<true, true>(&btoidsortsupport); }
+TExecFunc arrow_btoidvectorcmp() { return MakeIndirectExec<true, true>(&btoidvectorcmp); }
+TExecFunc arrow_btrim() { return MakeIndirectExec<true, false>(&btrim); }
+TExecFunc arrow_btrim1() { return MakeIndirectExec<true, false>(&btrim1); }
+TExecFunc arrow_bytealike() { return MakeIndirectExec<true, true>(&bytealike); }
+TExecFunc arrow_bytealtrim() { return MakeIndirectExec<true, false>(&bytealtrim); }
+TExecFunc arrow_byteanlike() { return MakeIndirectExec<true, true>(&byteanlike); }
+TExecFunc arrow_byteartrim() { return MakeIndirectExec<true, false>(&byteartrim); }
+TExecFunc arrow_byteatrim() { return MakeIndirectExec<true, false>(&byteatrim); }
+TExecFunc arrow_char_text() { return MakeIndirectExec<true, false>(&char_text); }
+TExecFunc arrow_chareq() { return MakeIndirectExec<true, true>(&chareq); }
+TExecFunc arrow_charge() { return MakeIndirectExec<true, true>(&charge); }
+TExecFunc arrow_chargt() { return MakeIndirectExec<true, true>(&chargt); }
+TExecFunc arrow_charin() { return MakeIndirectExec<true, true>(&charin); }
+TExecFunc arrow_charle() { return MakeIndirectExec<true, true>(&charle); }
+TExecFunc arrow_charlt() { return MakeIndirectExec<true, true>(&charlt); }
+TExecFunc arrow_charne() { return MakeIndirectExec<true, true>(&charne); }
+TExecFunc arrow_charout() { return MakeIndirectExec<true, false>(&charout); }
+TExecFunc arrow_charrecv() { return MakeIndirectExec<true, true>(&charrecv); }
+TExecFunc arrow_charsend() { return MakeIndirectExec<true, false>(&charsend); }
+TExecFunc arrow_chartoi4() { return MakeIndirectExec<true, true>(&chartoi4); }
+TExecFunc arrow_chr() { return MakeIndirectExec<true, false>(&chr); }
+TExecFunc arrow_cidr_abbrev() { return MakeIndirectExec<true, false>(&cidr_abbrev); }
+TExecFunc arrow_cidr_in() { return MakeIndirectExec<true, false>(&cidr_in); }
+TExecFunc arrow_cidr_out() { return MakeIndirectExec<true, false>(&cidr_out); }
+TExecFunc arrow_cidr_recv() { return MakeIndirectExec<true, false>(&cidr_recv); }
+TExecFunc arrow_cidr_send() { return MakeIndirectExec<true, false>(&cidr_send); }
+TExecFunc arrow_cidr_set_masklen() { return MakeIndirectExec<true, false>(&cidr_set_masklen); }
+TExecFunc arrow_daterange_canonical() { return MakeIndirectExec<true, false>(&daterange_canonical); }
+TExecFunc arrow_daterange_subdiff() { return MakeIndirectExec<true, true>(&daterange_subdiff); }
+TExecFunc arrow_elem_contained_by_range() { return MakeIndirectExec<true, true>(&elem_contained_by_range); }
+TExecFunc arrow_enum_cmp() { return MakeIndirectExec<true, true>(&enum_cmp); }
+TExecFunc arrow_enum_eq() { return MakeIndirectExec<true, true>(&enum_eq); }
+TExecFunc arrow_enum_first() { return MakeIndirectExec<false, true>(&enum_first); }
+TExecFunc arrow_enum_ge() { return MakeIndirectExec<true, true>(&enum_ge); }
+TExecFunc arrow_enum_gt() { return MakeIndirectExec<true, true>(&enum_gt); }
+TExecFunc arrow_enum_in() { return MakeIndirectExec<true, true>(&enum_in); }
+TExecFunc arrow_enum_larger() { return MakeIndirectExec<true, true>(&enum_larger); }
+TExecFunc arrow_enum_last() { return MakeIndirectExec<false, true>(&enum_last); }
+TExecFunc arrow_enum_le() { return MakeIndirectExec<true, true>(&enum_le); }
+TExecFunc arrow_enum_lt() { return MakeIndirectExec<true, true>(&enum_lt); }
+TExecFunc arrow_enum_ne() { return MakeIndirectExec<true, true>(&enum_ne); }
+TExecFunc arrow_enum_out() { return MakeIndirectExec<true, false>(&enum_out); }
+TExecFunc arrow_enum_range_all() { return MakeIndirectExec<false, false>(&enum_range_all); }
+TExecFunc arrow_enum_range_bounds() { return MakeIndirectExec<false, false>(&enum_range_bounds); }
+TExecFunc arrow_enum_recv() { return MakeIndirectExec<true, true>(&enum_recv); }
+TExecFunc arrow_enum_send() { return MakeIndirectExec<true, false>(&enum_send); }
+TExecFunc arrow_enum_smaller() { return MakeIndirectExec<true, true>(&enum_smaller); }
+TExecFunc arrow_eqjoinsel() { return MakeIndirectExec<true, true>(&eqjoinsel); }
+TExecFunc arrow_eqsel() { return MakeIndirectExec<true, true>(&eqsel); }
+TExecFunc arrow_fmgr_c_validator() { return MakeIndirectExec<true, true>(&fmgr_c_validator); }
+TExecFunc arrow_fmgr_internal_validator() { return MakeIndirectExec<true, true>(&fmgr_internal_validator); }
+TExecFunc arrow_fmgr_sql_validator() { return MakeIndirectExec<true, true>(&fmgr_sql_validator); }
+TExecFunc arrow_format_type() { return MakeIndirectExec<false, false>(&format_type); }
+TExecFunc arrow_gen_random_uuid() { return MakeIndirectExec<true, false>(&gen_random_uuid); }
+TExecFunc arrow_getdatabaseencoding() { return MakeIndirectExec<true, false>(&getdatabaseencoding); }
+TExecFunc arrow_gisthandler() { return MakeIndirectExec<true, true>(&gisthandler); }
+TExecFunc arrow_gtsvector_compress() { return MakeIndirectExec<true, true>(&gtsvector_compress); }
+TExecFunc arrow_gtsvector_consistent() { return MakeIndirectExec<true, true>(&gtsvector_consistent); }
+TExecFunc arrow_gtsvector_consistent_oldsig() { return MakeIndirectExec<true, true>(&gtsvector_consistent_oldsig); }
+TExecFunc arrow_gtsvector_decompress() { return MakeIndirectExec<true, true>(&gtsvector_decompress); }
+TExecFunc arrow_gtsvector_options() { return MakeIndirectExec<false, true>(&gtsvector_options); }
+TExecFunc arrow_gtsvector_penalty() { return MakeIndirectExec<true, true>(&gtsvector_penalty); }
+TExecFunc arrow_gtsvector_picksplit() { return MakeIndirectExec<true, true>(&gtsvector_picksplit); }
+TExecFunc arrow_gtsvector_same() { return MakeIndirectExec<true, true>(&gtsvector_same); }
+TExecFunc arrow_gtsvector_union() { return MakeIndirectExec<true, false>(&gtsvector_union); }
+TExecFunc arrow_gtsvectorin() { return MakeIndirectExec<true, false>(&gtsvectorin); }
+TExecFunc arrow_gtsvectorout() { return MakeIndirectExec<true, false>(&gtsvectorout); }
+TExecFunc arrow_hash_range() { return MakeIndirectExec<true, true>(&hash_range); }
+TExecFunc arrow_hash_range_extended() { return MakeIndirectExec<true, true>(&hash_range_extended); }
+TExecFunc arrow_hashchar() { return MakeIndirectExec<true, true>(&hashchar); }
+TExecFunc arrow_hashcharextended() { return MakeIndirectExec<true, true>(&hashcharextended); }
+TExecFunc arrow_hashenum() { return MakeIndirectExec<true, true>(&hashenum); }
+TExecFunc arrow_hashenumextended() { return MakeIndirectExec<true, true>(&hashenumextended); }
+TExecFunc arrow_hashfloat4() { return MakeIndirectExec<true, true>(&hashfloat4); }
+TExecFunc arrow_hashfloat4extended() { return MakeIndirectExec<true, true>(&hashfloat4extended); }
+TExecFunc arrow_hashfloat8() { return MakeIndirectExec<true, true>(&hashfloat8); }
+TExecFunc arrow_hashfloat8extended() { return MakeIndirectExec<true, true>(&hashfloat8extended); }
+TExecFunc arrow_hashinet() { return MakeIndirectExec<true, true>(&hashinet); }
+TExecFunc arrow_hashinetextended() { return MakeIndirectExec<true, true>(&hashinetextended); }
+TExecFunc arrow_hashint2() { return MakeIndirectExec<true, true>(&hashint2); }
+TExecFunc arrow_hashint2extended() { return MakeIndirectExec<true, true>(&hashint2extended); }
+TExecFunc arrow_hashint4() { return MakeIndirectExec<true, true>(&hashint4); }
+TExecFunc arrow_hashint4extended() { return MakeIndirectExec<true, true>(&hashint4extended); }
+TExecFunc arrow_hashint8() { return MakeIndirectExec<true, true>(&hashint8); }
+TExecFunc arrow_hashint8extended() { return MakeIndirectExec<true, true>(&hashint8extended); }
+TExecFunc arrow_hashmacaddr8() { return MakeIndirectExec<true, true>(&hashmacaddr8); }
+TExecFunc arrow_hashmacaddr8extended() { return MakeIndirectExec<true, true>(&hashmacaddr8extended); }
+TExecFunc arrow_hashname() { return MakeIndirectExec<true, true>(&hashname); }
+TExecFunc arrow_hashnameextended() { return MakeIndirectExec<true, true>(&hashnameextended); }
+TExecFunc arrow_hashoid() { return MakeIndirectExec<true, true>(&hashoid); }
+TExecFunc arrow_hashoidextended() { return MakeIndirectExec<true, true>(&hashoidextended); }
+TExecFunc arrow_hashoidvector() { return MakeIndirectExec<true, true>(&hashoidvector); }
+TExecFunc arrow_hashoidvectorextended() { return MakeIndirectExec<true, true>(&hashoidvectorextended); }
+TExecFunc arrow_hashtext() { return MakeIndirectExec<true, true>(&hashtext); }
+TExecFunc arrow_hashtextextended() { return MakeIndirectExec<true, true>(&hashtextextended); }
+TExecFunc arrow_hashvarlena() { return MakeIndirectExec<true, true>(&hashvarlena); }
+TExecFunc arrow_hashvarlenaextended() { return MakeIndirectExec<true, true>(&hashvarlenaextended); }
+TExecFunc arrow_heap_tableam_handler() { return MakeIndirectExec<true, true>(&heap_tableam_handler); }
+TExecFunc arrow_i4tochar() { return MakeIndirectExec<true, true>(&i4tochar); }
+TExecFunc arrow_inet_abbrev() { return MakeIndirectExec<true, false>(&inet_abbrev); }
+TExecFunc arrow_inet_client_addr() { return MakeIndirectExec<false, false>(&inet_client_addr); }
+TExecFunc arrow_inet_client_port() { return MakeIndirectExec<false, true>(&inet_client_port); }
+TExecFunc arrow_inet_in() { return MakeIndirectExec<true, false>(&inet_in); }
+TExecFunc arrow_inet_merge() { return MakeIndirectExec<true, false>(&inet_merge); }
+TExecFunc arrow_inet_out() { return MakeIndirectExec<true, false>(&inet_out); }
+TExecFunc arrow_inet_recv() { return MakeIndirectExec<true, false>(&inet_recv); }
+TExecFunc arrow_inet_same_family() { return MakeIndirectExec<true, true>(&inet_same_family); }
+TExecFunc arrow_inet_send() { return MakeIndirectExec<true, false>(&inet_send); }
+TExecFunc arrow_inet_server_addr() { return MakeIndirectExec<false, false>(&inet_server_addr); }
+TExecFunc arrow_inet_server_port() { return MakeIndirectExec<false, true>(&inet_server_port); }
+TExecFunc arrow_inet_set_masklen() { return MakeIndirectExec<true, false>(&inet_set_masklen); }
+TExecFunc arrow_inet_to_cidr() { return MakeIndirectExec<true, false>(&inet_to_cidr); }
+TExecFunc arrow_inetand() { return MakeIndirectExec<true, false>(&inetand); }
+TExecFunc arrow_inetmi() { return MakeIndirectExec<true, true>(&inetmi); }
+TExecFunc arrow_inetmi_int8() { return MakeIndirectExec<true, false>(&inetmi_int8); }
+TExecFunc arrow_inetnot() { return MakeIndirectExec<true, false>(&inetnot); }
+TExecFunc arrow_inetor() { return MakeIndirectExec<true, false>(&inetor); }
+TExecFunc arrow_inetpl() { return MakeIndirectExec<true, false>(&inetpl); }
+TExecFunc arrow_initcap() { return MakeIndirectExec<true, false>(&initcap); }
+TExecFunc arrow_int4range_canonical() { return MakeIndirectExec<true, false>(&int4range_canonical); }
+TExecFunc arrow_int4range_subdiff() { return MakeIndirectExec<true, true>(&int4range_subdiff); }
+TExecFunc arrow_int8range_canonical() { return MakeIndirectExec<true, false>(&int8range_canonical); }
+TExecFunc arrow_int8range_subdiff() { return MakeIndirectExec<true, true>(&int8range_subdiff); }
+TExecFunc arrow_json_agg_finalfn() { return MakeIndirectExec<false, false>(&json_agg_finalfn); }
+TExecFunc arrow_json_agg_transfn() { return MakeIndirectExec<false, true>(&json_agg_transfn); }
+TExecFunc arrow_json_array_element() { return MakeIndirectExec<true, false>(&json_array_element); }
+TExecFunc arrow_json_array_element_text() { return MakeIndirectExec<true, false>(&json_array_element_text); }
+TExecFunc arrow_json_array_length() { return MakeIndirectExec<true, true>(&json_array_length); }
+TExecFunc arrow_json_build_array_noargs() { return MakeIndirectExec<false, false>(&json_build_array_noargs); }
+TExecFunc arrow_json_build_object_noargs() { return MakeIndirectExec<false, false>(&json_build_object_noargs); }
+TExecFunc arrow_json_in() { return MakeIndirectExec<true, false>(&json_in); }
+TExecFunc arrow_json_object() { return MakeIndirectExec<true, false>(&json_object); }
+TExecFunc arrow_json_object_agg_finalfn() { return MakeIndirectExec<false, false>(&json_object_agg_finalfn); }
+TExecFunc arrow_json_object_agg_transfn() { return MakeIndirectExec<false, true>(&json_object_agg_transfn); }
+TExecFunc arrow_json_object_field() { return MakeIndirectExec<true, false>(&json_object_field); }
+TExecFunc arrow_json_object_field_text() { return MakeIndirectExec<true, false>(&json_object_field_text); }
+TExecFunc arrow_json_object_two_arg() { return MakeIndirectExec<true, false>(&json_object_two_arg); }
+TExecFunc arrow_json_out() { return MakeIndirectExec<true, false>(&json_out); }
+TExecFunc arrow_json_populate_record() { return MakeIndirectExec<false, true>(&json_populate_record); }
+TExecFunc arrow_json_recv() { return MakeIndirectExec<true, false>(&json_recv); }
+TExecFunc arrow_json_send() { return MakeIndirectExec<true, false>(&json_send); }
+TExecFunc arrow_json_strip_nulls() { return MakeIndirectExec<true, false>(&json_strip_nulls); }
+TExecFunc arrow_json_to_record() { return MakeIndirectExec<true, false>(&json_to_record); }
+TExecFunc arrow_json_typeof() { return MakeIndirectExec<true, false>(&json_typeof); }
+TExecFunc arrow_jsonb_agg_finalfn() { return MakeIndirectExec<false, false>(&jsonb_agg_finalfn); }
+TExecFunc arrow_jsonb_agg_transfn() { return MakeIndirectExec<false, true>(&jsonb_agg_transfn); }
+TExecFunc arrow_jsonb_array_element() { return MakeIndirectExec<true, false>(&jsonb_array_element); }
+TExecFunc arrow_jsonb_array_element_text() { return MakeIndirectExec<true, false>(&jsonb_array_element_text); }
+TExecFunc arrow_jsonb_array_length() { return MakeIndirectExec<true, true>(&jsonb_array_length); }
+TExecFunc arrow_jsonb_bool() { return MakeIndirectExec<true, true>(&jsonb_bool); }
+TExecFunc arrow_jsonb_build_array_noargs() { return MakeIndirectExec<false, false>(&jsonb_build_array_noargs); }
+TExecFunc arrow_jsonb_build_object_noargs() { return MakeIndirectExec<false, false>(&jsonb_build_object_noargs); }
+TExecFunc arrow_jsonb_concat() { return MakeIndirectExec<true, false>(&jsonb_concat); }
+TExecFunc arrow_jsonb_delete() { return MakeIndirectExec<true, false>(&jsonb_delete); }
+TExecFunc arrow_jsonb_delete_idx() { return MakeIndirectExec<true, false>(&jsonb_delete_idx); }
+TExecFunc arrow_jsonb_delete_path() { return MakeIndirectExec<true, false>(&jsonb_delete_path); }
+TExecFunc arrow_jsonb_float4() { return MakeIndirectExec<true, true>(&jsonb_float4); }
+TExecFunc arrow_jsonb_float8() { return MakeIndirectExec<true, true>(&jsonb_float8); }
+TExecFunc arrow_jsonb_in() { return MakeIndirectExec<true, false>(&jsonb_in); }
+TExecFunc arrow_jsonb_insert() { return MakeIndirectExec<true, false>(&jsonb_insert); }
+TExecFunc arrow_jsonb_int2() { return MakeIndirectExec<true, true>(&jsonb_int2); }
+TExecFunc arrow_jsonb_int4() { return MakeIndirectExec<true, true>(&jsonb_int4); }
+TExecFunc arrow_jsonb_int8() { return MakeIndirectExec<true, true>(&jsonb_int8); }
+TExecFunc arrow_jsonb_numeric() { return MakeIndirectExec<true, false>(&jsonb_numeric); }
+TExecFunc arrow_jsonb_object() { return MakeIndirectExec<true, false>(&jsonb_object); }
+TExecFunc arrow_jsonb_object_agg_finalfn() { return MakeIndirectExec<false, false>(&jsonb_object_agg_finalfn); }
+TExecFunc arrow_jsonb_object_agg_transfn() { return MakeIndirectExec<false, true>(&jsonb_object_agg_transfn); }
+TExecFunc arrow_jsonb_object_field() { return MakeIndirectExec<true, false>(&jsonb_object_field); }
+TExecFunc arrow_jsonb_object_field_text() { return MakeIndirectExec<true, false>(&jsonb_object_field_text); }
+TExecFunc arrow_jsonb_object_two_arg() { return MakeIndirectExec<true, false>(&jsonb_object_two_arg); }
+TExecFunc arrow_jsonb_out() { return MakeIndirectExec<true, false>(&jsonb_out); }
+TExecFunc arrow_jsonb_populate_record() { return MakeIndirectExec<false, true>(&jsonb_populate_record); }
+TExecFunc arrow_jsonb_pretty() { return MakeIndirectExec<true, false>(&jsonb_pretty); }
+TExecFunc arrow_jsonb_recv() { return MakeIndirectExec<true, false>(&jsonb_recv); }
+TExecFunc arrow_jsonb_send() { return MakeIndirectExec<true, false>(&jsonb_send); }
+TExecFunc arrow_jsonb_set() { return MakeIndirectExec<true, false>(&jsonb_set); }
+TExecFunc arrow_jsonb_set_lax() { return MakeIndirectExec<false, false>(&jsonb_set_lax); }
+TExecFunc arrow_jsonb_strip_nulls() { return MakeIndirectExec<true, false>(&jsonb_strip_nulls); }
+TExecFunc arrow_jsonb_subscript_handler() { return MakeIndirectExec<true, true>(&jsonb_subscript_handler); }
+TExecFunc arrow_jsonb_to_record() { return MakeIndirectExec<true, false>(&jsonb_to_record); }
+TExecFunc arrow_jsonb_typeof() { return MakeIndirectExec<true, false>(&jsonb_typeof); }
+TExecFunc arrow_jsonpath_in() { return MakeIndirectExec<true, false>(&jsonpath_in); }
+TExecFunc arrow_jsonpath_out() { return MakeIndirectExec<true, false>(&jsonpath_out); }
+TExecFunc arrow_jsonpath_recv() { return MakeIndirectExec<true, false>(&jsonpath_recv); }
+TExecFunc arrow_jsonpath_send() { return MakeIndirectExec<true, false>(&jsonpath_send); }
+TExecFunc arrow_length_in_encoding() { return MakeIndirectExec<true, true>(&length_in_encoding); }
+TExecFunc arrow_like_escape() { return MakeIndirectExec<true, false>(&like_escape); }
+TExecFunc arrow_like_escape_bytea() { return MakeIndirectExec<true, false>(&like_escape_bytea); }
+TExecFunc arrow_lower() { return MakeIndirectExec<true, false>(&lower); }
+TExecFunc arrow_lpad() { return MakeIndirectExec<true, false>(&lpad); }
+TExecFunc arrow_ltrim() { return MakeIndirectExec<true, false>(&ltrim); }
+TExecFunc arrow_ltrim1() { return MakeIndirectExec<true, false>(&ltrim1); }
+TExecFunc arrow_macaddr8_and() { return MakeIndirectExec<true, false>(&macaddr8_and); }
+TExecFunc arrow_macaddr8_cmp() { return MakeIndirectExec<true, true>(&macaddr8_cmp); }
+TExecFunc arrow_macaddr8_eq() { return MakeIndirectExec<true, true>(&macaddr8_eq); }
+TExecFunc arrow_macaddr8_ge() { return MakeIndirectExec<true, true>(&macaddr8_ge); }
+TExecFunc arrow_macaddr8_gt() { return MakeIndirectExec<true, true>(&macaddr8_gt); }
+TExecFunc arrow_macaddr8_in() { return MakeIndirectExec<true, false>(&macaddr8_in); }
+TExecFunc arrow_macaddr8_le() { return MakeIndirectExec<true, true>(&macaddr8_le); }
+TExecFunc arrow_macaddr8_lt() { return MakeIndirectExec<true, true>(&macaddr8_lt); }
+TExecFunc arrow_macaddr8_ne() { return MakeIndirectExec<true, true>(&macaddr8_ne); }
+TExecFunc arrow_macaddr8_not() { return MakeIndirectExec<true, false>(&macaddr8_not); }
+TExecFunc arrow_macaddr8_or() { return MakeIndirectExec<true, false>(&macaddr8_or); }
+TExecFunc arrow_macaddr8_out() { return MakeIndirectExec<true, false>(&macaddr8_out); }
+TExecFunc arrow_macaddr8_recv() { return MakeIndirectExec<true, false>(&macaddr8_recv); }
+TExecFunc arrow_macaddr8_send() { return MakeIndirectExec<true, false>(&macaddr8_send); }
+TExecFunc arrow_macaddr8_set7bit() { return MakeIndirectExec<true, false>(&macaddr8_set7bit); }
+TExecFunc arrow_macaddr8_trunc() { return MakeIndirectExec<true, false>(&macaddr8_trunc); }
+TExecFunc arrow_macaddr8tomacaddr() { return MakeIndirectExec<true, false>(&macaddr8tomacaddr); }
+TExecFunc arrow_macaddrtomacaddr8() { return MakeIndirectExec<true, false>(&macaddrtomacaddr8); }
+TExecFunc arrow_matchingjoinsel() { return MakeIndirectExec<true, true>(&matchingjoinsel); }
+TExecFunc arrow_matchingsel() { return MakeIndirectExec<true, true>(&matchingsel); }
+TExecFunc arrow_nameiclike() { return MakeIndirectExec<true, true>(&nameiclike); }
+TExecFunc arrow_nameicnlike() { return MakeIndirectExec<true, true>(&nameicnlike); }
+TExecFunc arrow_nameicregexeq() { return MakeIndirectExec<true, true>(&nameicregexeq); }
+TExecFunc arrow_nameicregexne() { return MakeIndirectExec<true, true>(&nameicregexne); }
+TExecFunc arrow_namelike() { return MakeIndirectExec<true, true>(&namelike); }
+TExecFunc arrow_namenlike() { return MakeIndirectExec<true, true>(&namenlike); }
+TExecFunc arrow_nameregexeq() { return MakeIndirectExec<true, true>(&nameregexeq); }
+TExecFunc arrow_nameregexne() { return MakeIndirectExec<true, true>(&nameregexne); }
+TExecFunc arrow_neqjoinsel() { return MakeIndirectExec<true, true>(&neqjoinsel); }
+TExecFunc arrow_neqsel() { return MakeIndirectExec<true, true>(&neqsel); }
+TExecFunc arrow_network_broadcast() { return MakeIndirectExec<true, false>(&network_broadcast); }
+TExecFunc arrow_network_cmp() { return MakeIndirectExec<true, true>(&network_cmp); }
+TExecFunc arrow_network_eq() { return MakeIndirectExec<true, true>(&network_eq); }
+TExecFunc arrow_network_family() { return MakeIndirectExec<true, true>(&network_family); }
+TExecFunc arrow_network_ge() { return MakeIndirectExec<true, true>(&network_ge); }
+TExecFunc arrow_network_gt() { return MakeIndirectExec<true, true>(&network_gt); }
+TExecFunc arrow_network_host() { return MakeIndirectExec<true, false>(&network_host); }
+TExecFunc arrow_network_hostmask() { return MakeIndirectExec<true, false>(&network_hostmask); }
+TExecFunc arrow_network_larger() { return MakeIndirectExec<true, false>(&network_larger); }
+TExecFunc arrow_network_le() { return MakeIndirectExec<true, true>(&network_le); }
+TExecFunc arrow_network_lt() { return MakeIndirectExec<true, true>(&network_lt); }
+TExecFunc arrow_network_masklen() { return MakeIndirectExec<true, true>(&network_masklen); }
+TExecFunc arrow_network_ne() { return MakeIndirectExec<true, true>(&network_ne); }
+TExecFunc arrow_network_netmask() { return MakeIndirectExec<true, false>(&network_netmask); }
+TExecFunc arrow_network_network() { return MakeIndirectExec<true, false>(&network_network); }
+TExecFunc arrow_network_overlap() { return MakeIndirectExec<true, true>(&network_overlap); }
+TExecFunc arrow_network_show() { return MakeIndirectExec<true, false>(&network_show); }
+TExecFunc arrow_network_smaller() { return MakeIndirectExec<true, false>(&network_smaller); }
+TExecFunc arrow_network_sortsupport() { return MakeIndirectExec<true, true>(&network_sortsupport); }
+TExecFunc arrow_network_sub() { return MakeIndirectExec<true, true>(&network_sub); }
+TExecFunc arrow_network_subeq() { return MakeIndirectExec<true, true>(&network_subeq); }
+TExecFunc arrow_network_subset_support() { return MakeIndirectExec<true, true>(&network_subset_support); }
+TExecFunc arrow_network_sup() { return MakeIndirectExec<true, true>(&network_sup); }
+TExecFunc arrow_network_supeq() { return MakeIndirectExec<true, true>(&network_supeq); }
+TExecFunc arrow_numrange_subdiff() { return MakeIndirectExec<true, true>(&numrange_subdiff); }
+TExecFunc arrow_oideq() { return MakeIndirectExec<true, true>(&oideq); }
+TExecFunc arrow_oidge() { return MakeIndirectExec<true, true>(&oidge); }
+TExecFunc arrow_oidgt() { return MakeIndirectExec<true, true>(&oidgt); }
+TExecFunc arrow_oidin() { return MakeIndirectExec<true, true>(&oidin); }
+TExecFunc arrow_oidlarger() { return MakeIndirectExec<true, true>(&oidlarger); }
+TExecFunc arrow_oidle() { return MakeIndirectExec<true, true>(&oidle); }
+TExecFunc arrow_oidlt() { return MakeIndirectExec<true, true>(&oidlt); }
+TExecFunc arrow_oidne() { return MakeIndirectExec<true, true>(&oidne); }
+TExecFunc arrow_oidout() { return MakeIndirectExec<true, false>(&oidout); }
+TExecFunc arrow_oidrecv() { return MakeIndirectExec<true, true>(&oidrecv); }
+TExecFunc arrow_oidsend() { return MakeIndirectExec<true, false>(&oidsend); }
+TExecFunc arrow_oidsmaller() { return MakeIndirectExec<true, true>(&oidsmaller); }
+TExecFunc arrow_oidvectoreq() { return MakeIndirectExec<true, true>(&oidvectoreq); }
+TExecFunc arrow_oidvectorge() { return MakeIndirectExec<true, true>(&oidvectorge); }
+TExecFunc arrow_oidvectorgt() { return MakeIndirectExec<true, true>(&oidvectorgt); }
+TExecFunc arrow_oidvectorin() { return MakeIndirectExec<true, false>(&oidvectorin); }
+TExecFunc arrow_oidvectorle() { return MakeIndirectExec<true, true>(&oidvectorle); }
+TExecFunc arrow_oidvectorlt() { return MakeIndirectExec<true, true>(&oidvectorlt); }
+TExecFunc arrow_oidvectorne() { return MakeIndirectExec<true, true>(&oidvectorne); }
+TExecFunc arrow_oidvectorout() { return MakeIndirectExec<true, false>(&oidvectorout); }
+TExecFunc arrow_oidvectorrecv() { return MakeIndirectExec<true, false>(&oidvectorrecv); }
+TExecFunc arrow_oidvectorsend() { return MakeIndirectExec<true, false>(&oidvectorsend); }
+TExecFunc arrow_oidvectortypes() { return MakeIndirectExec<true, false>(&oidvectortypes); }
+TExecFunc arrow_pg_cancel_backend() { return MakeIndirectExec<true, true>(&pg_cancel_backend); }
+TExecFunc arrow_pg_client_encoding() { return MakeIndirectExec<true, false>(&pg_client_encoding); }
+TExecFunc arrow_pg_convert() { return MakeIndirectExec<true, false>(&pg_convert); }
+TExecFunc arrow_pg_convert_from() { return MakeIndirectExec<true, false>(&pg_convert_from); }
+TExecFunc arrow_pg_convert_to() { return MakeIndirectExec<true, false>(&pg_convert_to); }
+TExecFunc arrow_pg_encoding_max_length_sql() { return MakeIndirectExec<true, true>(&pg_encoding_max_length_sql); }
+TExecFunc arrow_pg_export_snapshot() { return MakeIndirectExec<true, false>(&pg_export_snapshot); }
+TExecFunc arrow_pg_last_committed_xact() { return MakeIndirectExec<true, false>(&pg_last_committed_xact); }
+TExecFunc arrow_pg_log_backend_memory_contexts() { return MakeIndirectExec<true, true>(&pg_log_backend_memory_contexts); }
+TExecFunc arrow_pg_ndistinct_in() { return MakeIndirectExec<true, false>(&pg_ndistinct_in); }
+TExecFunc arrow_pg_ndistinct_out() { return MakeIndirectExec<true, false>(&pg_ndistinct_out); }
+TExecFunc arrow_pg_ndistinct_recv() { return MakeIndirectExec<true, false>(&pg_ndistinct_recv); }
+TExecFunc arrow_pg_ndistinct_send() { return MakeIndirectExec<true, false>(&pg_ndistinct_send); }
+TExecFunc arrow_pg_nextoid() { return MakeIndirectExec<true, true>(&pg_nextoid); }
+TExecFunc arrow_pg_reload_conf() { return MakeIndirectExec<true, true>(&pg_reload_conf); }
+TExecFunc arrow_pg_replication_origin_advance() { return MakeIndirectExec<true, true>(&pg_replication_origin_advance); }
+TExecFunc arrow_pg_replication_origin_create() { return MakeIndirectExec<true, true>(&pg_replication_origin_create); }
+TExecFunc arrow_pg_replication_origin_drop() { return MakeIndirectExec<true, true>(&pg_replication_origin_drop); }
+TExecFunc arrow_pg_replication_origin_oid() { return MakeIndirectExec<true, true>(&pg_replication_origin_oid); }
+TExecFunc arrow_pg_replication_origin_progress() { return MakeIndirectExec<true, true>(&pg_replication_origin_progress); }
+TExecFunc arrow_pg_replication_origin_session_is_setup() { return MakeIndirectExec<true, true>(&pg_replication_origin_session_is_setup); }
+TExecFunc arrow_pg_replication_origin_session_progress() { return MakeIndirectExec<true, true>(&pg_replication_origin_session_progress); }
+TExecFunc arrow_pg_replication_origin_session_reset() { return MakeIndirectExec<true, true>(&pg_replication_origin_session_reset); }
+TExecFunc arrow_pg_replication_origin_session_setup() { return MakeIndirectExec<true, true>(&pg_replication_origin_session_setup); }
+TExecFunc arrow_pg_replication_origin_xact_reset() { return MakeIndirectExec<true, true>(&pg_replication_origin_xact_reset); }
+TExecFunc arrow_pg_replication_origin_xact_setup() { return MakeIndirectExec<true, true>(&pg_replication_origin_xact_setup); }
+TExecFunc arrow_pg_rotate_logfile() { return MakeIndirectExec<true, true>(&pg_rotate_logfile); }
+TExecFunc arrow_pg_rotate_logfile_v2() { return MakeIndirectExec<true, true>(&pg_rotate_logfile_v2); }
+TExecFunc arrow_pg_terminate_backend() { return MakeIndirectExec<true, true>(&pg_terminate_backend); }
+TExecFunc arrow_pg_xact_commit_timestamp() { return MakeIndirectExec<true, true>(&pg_xact_commit_timestamp); }
+TExecFunc arrow_pg_xact_commit_timestamp_origin() { return MakeIndirectExec<true, false>(&pg_xact_commit_timestamp_origin); }
+TExecFunc arrow_pgsql_version() { return MakeIndirectExec<true, false>(&pgsql_version); }
+TExecFunc arrow_range_adjacent() { return MakeIndirectExec<true, true>(&range_adjacent); }
+TExecFunc arrow_range_after() { return MakeIndirectExec<true, true>(&range_after); }
+TExecFunc arrow_range_before() { return MakeIndirectExec<true, true>(&range_before); }
+TExecFunc arrow_range_cmp() { return MakeIndirectExec<true, true>(&range_cmp); }
+TExecFunc arrow_range_constructor2() { return MakeIndirectExec<false, false>(&range_constructor2); }
+TExecFunc arrow_range_constructor3() { return MakeIndirectExec<false, false>(&range_constructor3); }
+TExecFunc arrow_range_contained_by() { return MakeIndirectExec<true, true>(&range_contained_by); }
+TExecFunc arrow_range_contains() { return MakeIndirectExec<true, true>(&range_contains); }
+TExecFunc arrow_range_contains_elem() { return MakeIndirectExec<true, true>(&range_contains_elem); }
+TExecFunc arrow_range_empty() { return MakeIndirectExec<true, true>(&range_empty); }
+TExecFunc arrow_range_eq() { return MakeIndirectExec<true, true>(&range_eq); }
+TExecFunc arrow_range_ge() { return MakeIndirectExec<true, true>(&range_ge); }
+TExecFunc arrow_range_gt() { return MakeIndirectExec<true, true>(&range_gt); }
+TExecFunc arrow_range_in() { return MakeIndirectExec<true, false>(&range_in); }
+TExecFunc arrow_range_intersect() { return MakeIndirectExec<true, false>(&range_intersect); }
+TExecFunc arrow_range_intersect_agg_transfn() { return MakeIndirectExec<true, false>(&range_intersect_agg_transfn); }
+TExecFunc arrow_range_le() { return MakeIndirectExec<true, true>(&range_le); }
+TExecFunc arrow_range_lower() { return MakeIndirectExec<true, true>(&range_lower); }
+TExecFunc arrow_range_lower_inc() { return MakeIndirectExec<true, true>(&range_lower_inc); }
+TExecFunc arrow_range_lower_inf() { return MakeIndirectExec<true, true>(&range_lower_inf); }
+TExecFunc arrow_range_lt() { return MakeIndirectExec<true, true>(&range_lt); }
+TExecFunc arrow_range_merge() { return MakeIndirectExec<true, false>(&range_merge); }
+TExecFunc arrow_range_minus() { return MakeIndirectExec<true, false>(&range_minus); }
+TExecFunc arrow_range_ne() { return MakeIndirectExec<true, true>(&range_ne); }
+TExecFunc arrow_range_out() { return MakeIndirectExec<true, false>(&range_out); }
+TExecFunc arrow_range_overlaps() { return MakeIndirectExec<true, true>(&range_overlaps); }
+TExecFunc arrow_range_overleft() { return MakeIndirectExec<true, true>(&range_overleft); }
+TExecFunc arrow_range_overright() { return MakeIndirectExec<true, true>(&range_overright); }
+TExecFunc arrow_range_recv() { return MakeIndirectExec<true, false>(&range_recv); }
+TExecFunc arrow_range_send() { return MakeIndirectExec<true, false>(&range_send); }
+TExecFunc arrow_range_union() { return MakeIndirectExec<true, false>(&range_union); }
+TExecFunc arrow_range_upper() { return MakeIndirectExec<true, true>(&range_upper); }
+TExecFunc arrow_range_upper_inc() { return MakeIndirectExec<true, true>(&range_upper_inc); }
+TExecFunc arrow_range_upper_inf() { return MakeIndirectExec<true, true>(&range_upper_inf); }
+TExecFunc arrow_raw_array_subscript_handler() { return MakeIndirectExec<true, true>(&raw_array_subscript_handler); }
+TExecFunc arrow_regexp_match() { return MakeIndirectExec<true, false>(&regexp_match); }
+TExecFunc arrow_regexp_match_no_flags() { return MakeIndirectExec<true, false>(&regexp_match_no_flags); }
+TExecFunc arrow_regexp_split_to_array() { return MakeIndirectExec<true, false>(&regexp_split_to_array); }
+TExecFunc arrow_regexp_split_to_array_no_flags() { return MakeIndirectExec<true, false>(&regexp_split_to_array_no_flags); }
+TExecFunc arrow_repeat() { return MakeIndirectExec<true, false>(&repeat); }
+TExecFunc arrow_row_to_json() { return MakeIndirectExec<true, false>(&row_to_json); }
+TExecFunc arrow_row_to_json_pretty() { return MakeIndirectExec<true, false>(&row_to_json_pretty); }
+TExecFunc arrow_rpad() { return MakeIndirectExec<true, false>(&rpad); }
+TExecFunc arrow_rtrim() { return MakeIndirectExec<true, false>(&rtrim); }
+TExecFunc arrow_rtrim1() { return MakeIndirectExec<true, false>(&rtrim1); }
+TExecFunc arrow_scalargejoinsel() { return MakeIndirectExec<true, true>(&scalargejoinsel); }
+TExecFunc arrow_scalargesel() { return MakeIndirectExec<true, true>(&scalargesel); }
+TExecFunc arrow_scalargtjoinsel() { return MakeIndirectExec<true, true>(&scalargtjoinsel); }
+TExecFunc arrow_scalargtsel() { return MakeIndirectExec<true, true>(&scalargtsel); }
+TExecFunc arrow_scalarlejoinsel() { return MakeIndirectExec<true, true>(&scalarlejoinsel); }
+TExecFunc arrow_scalarlesel() { return MakeIndirectExec<true, true>(&scalarlesel); }
+TExecFunc arrow_scalarltjoinsel() { return MakeIndirectExec<true, true>(&scalarltjoinsel); }
+TExecFunc arrow_scalarltsel() { return MakeIndirectExec<true, true>(&scalarltsel); }
+TExecFunc arrow_set_config_by_name() { return MakeIndirectExec<false, false>(&set_config_by_name); }
+TExecFunc arrow_show_config_by_name() { return MakeIndirectExec<true, false>(&show_config_by_name); }
+TExecFunc arrow_show_config_by_name_missing_ok() { return MakeIndirectExec<true, false>(&show_config_by_name_missing_ok); }
+TExecFunc arrow_similar_escape() { return MakeIndirectExec<false, false>(&similar_escape); }
+TExecFunc arrow_similar_to_escape_1() { return MakeIndirectExec<true, false>(&similar_to_escape_1); }
+TExecFunc arrow_similar_to_escape_2() { return MakeIndirectExec<true, false>(&similar_to_escape_2); }
+TExecFunc arrow_text_char() { return MakeIndirectExec<true, true>(&text_char); }
+TExecFunc arrow_texticlike() { return MakeIndirectExec<true, true>(&texticlike); }
+TExecFunc arrow_texticnlike() { return MakeIndirectExec<true, true>(&texticnlike); }
+TExecFunc arrow_texticregexeq() { return MakeIndirectExec<true, true>(&texticregexeq); }
+TExecFunc arrow_texticregexne() { return MakeIndirectExec<true, true>(&texticregexne); }
+TExecFunc arrow_textlike() { return MakeIndirectExec<true, true>(&textlike); }
+TExecFunc arrow_textnlike() { return MakeIndirectExec<true, true>(&textnlike); }
+TExecFunc arrow_textregexeq() { return MakeIndirectExec<true, true>(&textregexeq); }
+TExecFunc arrow_textregexne() { return MakeIndirectExec<true, true>(&textregexne); }
+TExecFunc arrow_textregexreplace() { return MakeIndirectExec<true, false>(&textregexreplace); }
+TExecFunc arrow_textregexreplace_noopt() { return MakeIndirectExec<true, false>(&textregexreplace_noopt); }
+TExecFunc arrow_textregexsubstr() { return MakeIndirectExec<true, false>(&textregexsubstr); }
+TExecFunc arrow_to_json() { return MakeIndirectExec<true, false>(&to_json); }
+TExecFunc arrow_to_jsonb() { return MakeIndirectExec<true, false>(&to_jsonb); }
+TExecFunc arrow_translate() { return MakeIndirectExec<true, false>(&translate); }
+TExecFunc arrow_tsqueryin() { return MakeIndirectExec<true, false>(&tsqueryin); }
+TExecFunc arrow_tsqueryout() { return MakeIndirectExec<true, false>(&tsqueryout); }
+TExecFunc arrow_tsqueryrecv() { return MakeIndirectExec<true, false>(&tsqueryrecv); }
+TExecFunc arrow_tsquerysend() { return MakeIndirectExec<true, false>(&tsquerysend); }
+TExecFunc arrow_tsquerytree() { return MakeIndirectExec<true, false>(&tsquerytree); }
+TExecFunc arrow_tsrange_subdiff() { return MakeIndirectExec<true, true>(&tsrange_subdiff); }
+TExecFunc arrow_tstzrange_subdiff() { return MakeIndirectExec<true, true>(&tstzrange_subdiff); }
+TExecFunc arrow_upper() { return MakeIndirectExec<true, false>(&upper); }
+TExecFunc arrow_uuid_cmp() { return MakeIndirectExec<true, true>(&uuid_cmp); }
+TExecFunc arrow_uuid_eq() { return MakeIndirectExec<true, true>(&uuid_eq); }
+TExecFunc arrow_uuid_ge() { return MakeIndirectExec<true, true>(&uuid_ge); }
+TExecFunc arrow_uuid_gt() { return MakeIndirectExec<true, true>(&uuid_gt); }
+TExecFunc arrow_uuid_hash() { return MakeIndirectExec<true, true>(&uuid_hash); }
+TExecFunc arrow_uuid_hash_extended() { return MakeIndirectExec<true, true>(&uuid_hash_extended); }
+TExecFunc arrow_uuid_in() { return MakeIndirectExec<true, false>(&uuid_in); }
+TExecFunc arrow_uuid_le() { return MakeIndirectExec<true, true>(&uuid_le); }
+TExecFunc arrow_uuid_lt() { return MakeIndirectExec<true, true>(&uuid_lt); }
+TExecFunc arrow_uuid_ne() { return MakeIndirectExec<true, true>(&uuid_ne); }
+TExecFunc arrow_uuid_out() { return MakeIndirectExec<true, false>(&uuid_out); }
+TExecFunc arrow_uuid_recv() { return MakeIndirectExec<true, false>(&uuid_recv); }
+TExecFunc arrow_uuid_send() { return MakeIndirectExec<true, false>(&uuid_send); }
+TExecFunc arrow_uuid_sortsupport() { return MakeIndirectExec<true, true>(&uuid_sortsupport); }
diff --git a/ydb/library/yql/parser/pg_wrapper/pg_kernels.slow.1.inc b/ydb/library/yql/parser/pg_wrapper/pg_kernels.slow.1.inc
new file mode 100644
index 00000000000..a29a374fba2
--- /dev/null
+++ b/ydb/library/yql/parser/pg_wrapper/pg_kernels.slow.1.inc
@@ -0,0 +1,737 @@
+TExecFunc arrow_aclcontains() { return MakeIndirectExec<true, true>(&aclcontains); }
+TExecFunc arrow_acldefault_sql() { return MakeIndirectExec<true, false>(&acldefault_sql); }
+TExecFunc arrow_aclinsert() { return MakeIndirectExec<true, false>(&aclinsert); }
+TExecFunc arrow_aclitem_eq() { return MakeIndirectExec<true, true>(&aclitem_eq); }
+TExecFunc arrow_aclitemin() { return MakeIndirectExec<true, false>(&aclitemin); }
+TExecFunc arrow_aclitemout() { return MakeIndirectExec<true, false>(&aclitemout); }
+TExecFunc arrow_aclremove() { return MakeIndirectExec<true, false>(&aclremove); }
+TExecFunc arrow_amvalidate() { return MakeIndirectExec<true, true>(&amvalidate); }
+TExecFunc arrow_array_cardinality() { return MakeIndirectExec<true, true>(&array_cardinality); }
+TExecFunc arrow_array_dims() { return MakeIndirectExec<true, false>(&array_dims); }
+TExecFunc arrow_array_eq() { return MakeIndirectExec<true, true>(&array_eq); }
+TExecFunc arrow_array_fill() { return MakeIndirectExec<false, false>(&array_fill); }
+TExecFunc arrow_array_fill_with_lower_bounds() { return MakeIndirectExec<false, false>(&array_fill_with_lower_bounds); }
+TExecFunc arrow_array_ge() { return MakeIndirectExec<true, true>(&array_ge); }
+TExecFunc arrow_array_gt() { return MakeIndirectExec<true, true>(&array_gt); }
+TExecFunc arrow_array_in() { return MakeIndirectExec<true, false>(&array_in); }
+TExecFunc arrow_array_larger() { return MakeIndirectExec<true, false>(&array_larger); }
+TExecFunc arrow_array_le() { return MakeIndirectExec<true, true>(&array_le); }
+TExecFunc arrow_array_length() { return MakeIndirectExec<true, true>(&array_length); }
+TExecFunc arrow_array_lower() { return MakeIndirectExec<true, true>(&array_lower); }
+TExecFunc arrow_array_lt() { return MakeIndirectExec<true, true>(&array_lt); }
+TExecFunc arrow_array_ndims() { return MakeIndirectExec<true, true>(&array_ndims); }
+TExecFunc arrow_array_ne() { return MakeIndirectExec<true, true>(&array_ne); }
+TExecFunc arrow_array_out() { return MakeIndirectExec<true, false>(&array_out); }
+TExecFunc arrow_array_recv() { return MakeIndirectExec<true, false>(&array_recv); }
+TExecFunc arrow_array_remove() { return MakeIndirectExec<false, false>(&array_remove); }
+TExecFunc arrow_array_replace() { return MakeIndirectExec<false, false>(&array_replace); }
+TExecFunc arrow_array_send() { return MakeIndirectExec<true, false>(&array_send); }
+TExecFunc arrow_array_smaller() { return MakeIndirectExec<true, false>(&array_smaller); }
+TExecFunc arrow_array_to_text() { return MakeIndirectExec<true, false>(&array_to_text); }
+TExecFunc arrow_array_to_text_null() { return MakeIndirectExec<false, false>(&array_to_text_null); }
+TExecFunc arrow_array_to_tsvector() { return MakeIndirectExec<true, false>(&array_to_tsvector); }
+TExecFunc arrow_array_unnest_support() { return MakeIndirectExec<true, true>(&array_unnest_support); }
+TExecFunc arrow_array_upper() { return MakeIndirectExec<true, true>(&array_upper); }
+TExecFunc arrow_arraycontained() { return MakeIndirectExec<true, true>(&arraycontained); }
+TExecFunc arrow_arraycontains() { return MakeIndirectExec<true, true>(&arraycontains); }
+TExecFunc arrow_arrayoverlap() { return MakeIndirectExec<true, true>(&arrayoverlap); }
+TExecFunc arrow_binary_upgrade_create_empty_extension() { return MakeIndirectExec<false, true>(&binary_upgrade_create_empty_extension); }
+TExecFunc arrow_binary_upgrade_set_missing_value() { return MakeIndirectExec<true, true>(&binary_upgrade_set_missing_value); }
+TExecFunc arrow_binary_upgrade_set_next_array_pg_type_oid() { return MakeIndirectExec<true, true>(&binary_upgrade_set_next_array_pg_type_oid); }
+TExecFunc arrow_binary_upgrade_set_next_heap_pg_class_oid() { return MakeIndirectExec<true, true>(&binary_upgrade_set_next_heap_pg_class_oid); }
+TExecFunc arrow_binary_upgrade_set_next_index_pg_class_oid() { return MakeIndirectExec<true, true>(&binary_upgrade_set_next_index_pg_class_oid); }
+TExecFunc arrow_binary_upgrade_set_next_multirange_array_pg_type_oid() { return MakeIndirectExec<true, true>(&binary_upgrade_set_next_multirange_array_pg_type_oid); }
+TExecFunc arrow_binary_upgrade_set_next_multirange_pg_type_oid() { return MakeIndirectExec<true, true>(&binary_upgrade_set_next_multirange_pg_type_oid); }
+TExecFunc arrow_binary_upgrade_set_next_pg_authid_oid() { return MakeIndirectExec<true, true>(&binary_upgrade_set_next_pg_authid_oid); }
+TExecFunc arrow_binary_upgrade_set_next_pg_enum_oid() { return MakeIndirectExec<true, true>(&binary_upgrade_set_next_pg_enum_oid); }
+TExecFunc arrow_binary_upgrade_set_next_pg_type_oid() { return MakeIndirectExec<true, true>(&binary_upgrade_set_next_pg_type_oid); }
+TExecFunc arrow_binary_upgrade_set_next_toast_pg_class_oid() { return MakeIndirectExec<true, true>(&binary_upgrade_set_next_toast_pg_class_oid); }
+TExecFunc arrow_binary_upgrade_set_record_init_privs() { return MakeIndirectExec<true, true>(&binary_upgrade_set_record_init_privs); }
+TExecFunc arrow_bool_int4() { return MakeIndirectExec<true, true>(&bool_int4); }
+TExecFunc arrow_brin_inclusion_add_value() { return MakeIndirectExec<true, true>(&brin_inclusion_add_value); }
+TExecFunc arrow_brin_inclusion_consistent() { return MakeIndirectExec<true, true>(&brin_inclusion_consistent); }
+TExecFunc arrow_brin_inclusion_opcinfo() { return MakeIndirectExec<true, true>(&brin_inclusion_opcinfo); }
+TExecFunc arrow_brin_inclusion_union() { return MakeIndirectExec<true, true>(&brin_inclusion_union); }
+TExecFunc arrow_btarraycmp() { return MakeIndirectExec<true, true>(&btarraycmp); }
+TExecFunc arrow_btequalimage() { return MakeIndirectExec<true, true>(&btequalimage); }
+TExecFunc arrow_bthandler() { return MakeIndirectExec<true, true>(&bthandler); }
+TExecFunc arrow_btnametextcmp() { return MakeIndirectExec<true, true>(&btnametextcmp); }
+TExecFunc arrow_bttext_pattern_cmp() { return MakeIndirectExec<true, true>(&bttext_pattern_cmp); }
+TExecFunc arrow_bttext_pattern_sortsupport() { return MakeIndirectExec<true, true>(&bttext_pattern_sortsupport); }
+TExecFunc arrow_bttextcmp() { return MakeIndirectExec<true, true>(&bttextcmp); }
+TExecFunc arrow_bttextnamecmp() { return MakeIndirectExec<true, true>(&bttextnamecmp); }
+TExecFunc arrow_bttextsortsupport() { return MakeIndirectExec<true, true>(&bttextsortsupport); }
+TExecFunc arrow_btvarstrequalimage() { return MakeIndirectExec<true, true>(&btvarstrequalimage); }
+TExecFunc arrow_byteaGetBit() { return MakeIndirectExec<true, true>(&byteaGetBit); }
+TExecFunc arrow_byteaGetByte() { return MakeIndirectExec<true, true>(&byteaGetByte); }
+TExecFunc arrow_byteaSetBit() { return MakeIndirectExec<true, false>(&byteaSetBit); }
+TExecFunc arrow_byteaSetByte() { return MakeIndirectExec<true, false>(&byteaSetByte); }
+TExecFunc arrow_bytea_bit_count() { return MakeIndirectExec<true, true>(&bytea_bit_count); }
+TExecFunc arrow_bytea_sortsupport() { return MakeIndirectExec<true, true>(&bytea_sortsupport); }
+TExecFunc arrow_bytea_string_agg_finalfn() { return MakeIndirectExec<false, false>(&bytea_string_agg_finalfn); }
+TExecFunc arrow_bytea_string_agg_transfn() { return MakeIndirectExec<false, true>(&bytea_string_agg_transfn); }
+TExecFunc arrow_bytea_substr() { return MakeIndirectExec<true, false>(&bytea_substr); }
+TExecFunc arrow_bytea_substr_no_len() { return MakeIndirectExec<true, false>(&bytea_substr_no_len); }
+TExecFunc arrow_byteacat() { return MakeIndirectExec<true, false>(&byteacat); }
+TExecFunc arrow_byteacmp() { return MakeIndirectExec<true, true>(&byteacmp); }
+TExecFunc arrow_byteaeq() { return MakeIndirectExec<true, true>(&byteaeq); }
+TExecFunc arrow_byteage() { return MakeIndirectExec<true, true>(&byteage); }
+TExecFunc arrow_byteagt() { return MakeIndirectExec<true, true>(&byteagt); }
+TExecFunc arrow_byteain() { return MakeIndirectExec<true, false>(&byteain); }
+TExecFunc arrow_byteale() { return MakeIndirectExec<true, true>(&byteale); }
+TExecFunc arrow_bytealt() { return MakeIndirectExec<true, true>(&bytealt); }
+TExecFunc arrow_byteane() { return MakeIndirectExec<true, true>(&byteane); }
+TExecFunc arrow_byteaoctetlen() { return MakeIndirectExec<true, true>(&byteaoctetlen); }
+TExecFunc arrow_byteaout() { return MakeIndirectExec<true, false>(&byteaout); }
+TExecFunc arrow_byteaoverlay() { return MakeIndirectExec<true, false>(&byteaoverlay); }
+TExecFunc arrow_byteaoverlay_no_len() { return MakeIndirectExec<true, false>(&byteaoverlay_no_len); }
+TExecFunc arrow_byteapos() { return MakeIndirectExec<true, true>(&byteapos); }
+TExecFunc arrow_bytearecv() { return MakeIndirectExec<true, false>(&bytearecv); }
+TExecFunc arrow_byteasend() { return MakeIndirectExec<true, false>(&byteasend); }
+TExecFunc arrow_cursor_to_xml() { return MakeIndirectExec<true, false>(&cursor_to_xml); }
+TExecFunc arrow_cursor_to_xmlschema() { return MakeIndirectExec<true, false>(&cursor_to_xmlschema); }
+TExecFunc arrow_database_to_xml() { return MakeIndirectExec<true, false>(&database_to_xml); }
+TExecFunc arrow_database_to_xml_and_xmlschema() { return MakeIndirectExec<true, false>(&database_to_xml_and_xmlschema); }
+TExecFunc arrow_database_to_xmlschema() { return MakeIndirectExec<true, false>(&database_to_xmlschema); }
+TExecFunc arrow_date_cmp() { return MakeIndirectExec<true, true>(&date_cmp); }
+TExecFunc arrow_date_cmp_timestamp() { return MakeIndirectExec<true, true>(&date_cmp_timestamp); }
+TExecFunc arrow_date_cmp_timestamptz() { return MakeIndirectExec<true, true>(&date_cmp_timestamptz); }
+TExecFunc arrow_date_eq() { return MakeIndirectExec<true, true>(&date_eq); }
+TExecFunc arrow_date_eq_timestamp() { return MakeIndirectExec<true, true>(&date_eq_timestamp); }
+TExecFunc arrow_date_eq_timestamptz() { return MakeIndirectExec<true, true>(&date_eq_timestamptz); }
+TExecFunc arrow_date_finite() { return MakeIndirectExec<true, true>(&date_finite); }
+TExecFunc arrow_date_ge() { return MakeIndirectExec<true, true>(&date_ge); }
+TExecFunc arrow_date_ge_timestamp() { return MakeIndirectExec<true, true>(&date_ge_timestamp); }
+TExecFunc arrow_date_ge_timestamptz() { return MakeIndirectExec<true, true>(&date_ge_timestamptz); }
+TExecFunc arrow_date_gt() { return MakeIndirectExec<true, true>(&date_gt); }
+TExecFunc arrow_date_gt_timestamp() { return MakeIndirectExec<true, true>(&date_gt_timestamp); }
+TExecFunc arrow_date_gt_timestamptz() { return MakeIndirectExec<true, true>(&date_gt_timestamptz); }
+TExecFunc arrow_date_in() { return MakeIndirectExec<true, true>(&date_in); }
+TExecFunc arrow_date_larger() { return MakeIndirectExec<true, true>(&date_larger); }
+TExecFunc arrow_date_le() { return MakeIndirectExec<true, true>(&date_le); }
+TExecFunc arrow_date_le_timestamp() { return MakeIndirectExec<true, true>(&date_le_timestamp); }
+TExecFunc arrow_date_le_timestamptz() { return MakeIndirectExec<true, true>(&date_le_timestamptz); }
+TExecFunc arrow_date_lt() { return MakeIndirectExec<true, true>(&date_lt); }
+TExecFunc arrow_date_lt_timestamp() { return MakeIndirectExec<true, true>(&date_lt_timestamp); }
+TExecFunc arrow_date_lt_timestamptz() { return MakeIndirectExec<true, true>(&date_lt_timestamptz); }
+TExecFunc arrow_date_mi() { return MakeIndirectExec<true, true>(&date_mi); }
+TExecFunc arrow_date_mi_interval() { return MakeIndirectExec<true, true>(&date_mi_interval); }
+TExecFunc arrow_date_mii() { return MakeIndirectExec<true, true>(&date_mii); }
+TExecFunc arrow_date_ne() { return MakeIndirectExec<true, true>(&date_ne); }
+TExecFunc arrow_date_ne_timestamp() { return MakeIndirectExec<true, true>(&date_ne_timestamp); }
+TExecFunc arrow_date_ne_timestamptz() { return MakeIndirectExec<true, true>(&date_ne_timestamptz); }
+TExecFunc arrow_date_out() { return MakeIndirectExec<true, false>(&date_out); }
+TExecFunc arrow_date_pl_interval() { return MakeIndirectExec<true, true>(&date_pl_interval); }
+TExecFunc arrow_date_pli() { return MakeIndirectExec<true, true>(&date_pli); }
+TExecFunc arrow_date_recv() { return MakeIndirectExec<true, true>(&date_recv); }
+TExecFunc arrow_date_send() { return MakeIndirectExec<true, false>(&date_send); }
+TExecFunc arrow_date_smaller() { return MakeIndirectExec<true, true>(&date_smaller); }
+TExecFunc arrow_date_sortsupport() { return MakeIndirectExec<true, true>(&date_sortsupport); }
+TExecFunc arrow_date_timestamp() { return MakeIndirectExec<true, true>(&date_timestamp); }
+TExecFunc arrow_date_timestamptz() { return MakeIndirectExec<true, true>(&date_timestamptz); }
+TExecFunc arrow_datetime_timestamp() { return MakeIndirectExec<true, true>(&datetime_timestamp); }
+TExecFunc arrow_datetimetz_timestamptz() { return MakeIndirectExec<true, true>(&datetimetz_timestamptz); }
+TExecFunc arrow_dsimple_init() { return MakeIndirectExec<true, true>(&dsimple_init); }
+TExecFunc arrow_dsimple_lexize() { return MakeIndirectExec<true, true>(&dsimple_lexize); }
+TExecFunc arrow_dtoi8() { return MakeIndirectExec<true, true>(&dtoi8); }
+TExecFunc arrow_extract_date() { return MakeIndirectExec<true, false>(&extract_date); }
+TExecFunc arrow_extract_time() { return MakeIndirectExec<true, false>(&extract_time); }
+TExecFunc arrow_extract_timetz() { return MakeIndirectExec<true, false>(&extract_timetz); }
+TExecFunc arrow_ftoi8() { return MakeIndirectExec<true, true>(&ftoi8); }
+TExecFunc arrow_generate_series_int4_support() { return MakeIndirectExec<true, true>(&generate_series_int4_support); }
+TExecFunc arrow_generate_series_int8_support() { return MakeIndirectExec<true, true>(&generate_series_int8_support); }
+TExecFunc arrow_get_current_ts_config() { return MakeIndirectExec<true, true>(&get_current_ts_config); }
+TExecFunc arrow_gin_cmp_prefix() { return MakeIndirectExec<true, true>(&gin_cmp_prefix); }
+TExecFunc arrow_gin_cmp_tslexeme() { return MakeIndirectExec<true, true>(&gin_cmp_tslexeme); }
+TExecFunc arrow_gin_compare_jsonb() { return MakeIndirectExec<true, true>(&gin_compare_jsonb); }
+TExecFunc arrow_gin_consistent_jsonb() { return MakeIndirectExec<true, true>(&gin_consistent_jsonb); }
+TExecFunc arrow_gin_consistent_jsonb_path() { return MakeIndirectExec<true, true>(&gin_consistent_jsonb_path); }
+TExecFunc arrow_gin_extract_jsonb() { return MakeIndirectExec<true, true>(&gin_extract_jsonb); }
+TExecFunc arrow_gin_extract_jsonb_path() { return MakeIndirectExec<true, true>(&gin_extract_jsonb_path); }
+TExecFunc arrow_gin_extract_jsonb_query() { return MakeIndirectExec<true, true>(&gin_extract_jsonb_query); }
+TExecFunc arrow_gin_extract_jsonb_query_path() { return MakeIndirectExec<true, true>(&gin_extract_jsonb_query_path); }
+TExecFunc arrow_gin_extract_tsquery() { return MakeIndirectExec<true, true>(&gin_extract_tsquery); }
+TExecFunc arrow_gin_extract_tsquery_5args() { return MakeIndirectExec<true, true>(&gin_extract_tsquery_5args); }
+TExecFunc arrow_gin_extract_tsquery_oldsig() { return MakeIndirectExec<true, true>(&gin_extract_tsquery_oldsig); }
+TExecFunc arrow_gin_extract_tsvector() { return MakeIndirectExec<true, true>(&gin_extract_tsvector); }
+TExecFunc arrow_gin_extract_tsvector_2args() { return MakeIndirectExec<true, true>(&gin_extract_tsvector_2args); }
+TExecFunc arrow_gin_triconsistent_jsonb() { return MakeIndirectExec<true, true>(&gin_triconsistent_jsonb); }
+TExecFunc arrow_gin_triconsistent_jsonb_path() { return MakeIndirectExec<true, true>(&gin_triconsistent_jsonb_path); }
+TExecFunc arrow_gin_tsquery_consistent() { return MakeIndirectExec<true, true>(&gin_tsquery_consistent); }
+TExecFunc arrow_gin_tsquery_consistent_6args() { return MakeIndirectExec<true, true>(&gin_tsquery_consistent_6args); }
+TExecFunc arrow_gin_tsquery_consistent_oldsig() { return MakeIndirectExec<true, true>(&gin_tsquery_consistent_oldsig); }
+TExecFunc arrow_gin_tsquery_triconsistent() { return MakeIndirectExec<true, true>(&gin_tsquery_triconsistent); }
+TExecFunc arrow_gtsquery_compress() { return MakeIndirectExec<true, true>(&gtsquery_compress); }
+TExecFunc arrow_gtsquery_consistent() { return MakeIndirectExec<true, true>(&gtsquery_consistent); }
+TExecFunc arrow_gtsquery_consistent_oldsig() { return MakeIndirectExec<true, true>(&gtsquery_consistent_oldsig); }
+TExecFunc arrow_gtsquery_penalty() { return MakeIndirectExec<true, true>(&gtsquery_penalty); }
+TExecFunc arrow_gtsquery_picksplit() { return MakeIndirectExec<true, true>(&gtsquery_picksplit); }
+TExecFunc arrow_gtsquery_same() { return MakeIndirectExec<true, true>(&gtsquery_same); }
+TExecFunc arrow_gtsquery_union() { return MakeIndirectExec<true, true>(&gtsquery_union); }
+TExecFunc arrow_has_any_column_privilege_id() { return MakeIndirectExec<true, true>(&has_any_column_privilege_id); }
+TExecFunc arrow_has_any_column_privilege_id_id() { return MakeIndirectExec<true, true>(&has_any_column_privilege_id_id); }
+TExecFunc arrow_has_any_column_privilege_id_name() { return MakeIndirectExec<true, true>(&has_any_column_privilege_id_name); }
+TExecFunc arrow_has_any_column_privilege_name() { return MakeIndirectExec<true, true>(&has_any_column_privilege_name); }
+TExecFunc arrow_has_any_column_privilege_name_id() { return MakeIndirectExec<true, true>(&has_any_column_privilege_name_id); }
+TExecFunc arrow_has_any_column_privilege_name_name() { return MakeIndirectExec<true, true>(&has_any_column_privilege_name_name); }
+TExecFunc arrow_has_column_privilege_id_attnum() { return MakeIndirectExec<true, true>(&has_column_privilege_id_attnum); }
+TExecFunc arrow_has_column_privilege_id_id_attnum() { return MakeIndirectExec<true, true>(&has_column_privilege_id_id_attnum); }
+TExecFunc arrow_has_column_privilege_id_id_name() { return MakeIndirectExec<true, true>(&has_column_privilege_id_id_name); }
+TExecFunc arrow_has_column_privilege_id_name() { return MakeIndirectExec<true, true>(&has_column_privilege_id_name); }
+TExecFunc arrow_has_column_privilege_id_name_attnum() { return MakeIndirectExec<true, true>(&has_column_privilege_id_name_attnum); }
+TExecFunc arrow_has_column_privilege_id_name_name() { return MakeIndirectExec<true, true>(&has_column_privilege_id_name_name); }
+TExecFunc arrow_has_column_privilege_name_attnum() { return MakeIndirectExec<true, true>(&has_column_privilege_name_attnum); }
+TExecFunc arrow_has_column_privilege_name_id_attnum() { return MakeIndirectExec<true, true>(&has_column_privilege_name_id_attnum); }
+TExecFunc arrow_has_column_privilege_name_id_name() { return MakeIndirectExec<true, true>(&has_column_privilege_name_id_name); }
+TExecFunc arrow_has_column_privilege_name_name() { return MakeIndirectExec<true, true>(&has_column_privilege_name_name); }
+TExecFunc arrow_has_column_privilege_name_name_attnum() { return MakeIndirectExec<true, true>(&has_column_privilege_name_name_attnum); }
+TExecFunc arrow_has_column_privilege_name_name_name() { return MakeIndirectExec<true, true>(&has_column_privilege_name_name_name); }
+TExecFunc arrow_has_database_privilege_id() { return MakeIndirectExec<true, true>(&has_database_privilege_id); }
+TExecFunc arrow_has_database_privilege_id_id() { return MakeIndirectExec<true, true>(&has_database_privilege_id_id); }
+TExecFunc arrow_has_database_privilege_id_name() { return MakeIndirectExec<true, true>(&has_database_privilege_id_name); }
+TExecFunc arrow_has_database_privilege_name() { return MakeIndirectExec<true, true>(&has_database_privilege_name); }
+TExecFunc arrow_has_database_privilege_name_id() { return MakeIndirectExec<true, true>(&has_database_privilege_name_id); }
+TExecFunc arrow_has_database_privilege_name_name() { return MakeIndirectExec<true, true>(&has_database_privilege_name_name); }
+TExecFunc arrow_has_foreign_data_wrapper_privilege_id() { return MakeIndirectExec<true, true>(&has_foreign_data_wrapper_privilege_id); }
+TExecFunc arrow_has_foreign_data_wrapper_privilege_id_id() { return MakeIndirectExec<true, true>(&has_foreign_data_wrapper_privilege_id_id); }
+TExecFunc arrow_has_foreign_data_wrapper_privilege_id_name() { return MakeIndirectExec<true, true>(&has_foreign_data_wrapper_privilege_id_name); }
+TExecFunc arrow_has_foreign_data_wrapper_privilege_name() { return MakeIndirectExec<true, true>(&has_foreign_data_wrapper_privilege_name); }
+TExecFunc arrow_has_foreign_data_wrapper_privilege_name_id() { return MakeIndirectExec<true, true>(&has_foreign_data_wrapper_privilege_name_id); }
+TExecFunc arrow_has_foreign_data_wrapper_privilege_name_name() { return MakeIndirectExec<true, true>(&has_foreign_data_wrapper_privilege_name_name); }
+TExecFunc arrow_has_function_privilege_id() { return MakeIndirectExec<true, true>(&has_function_privilege_id); }
+TExecFunc arrow_has_function_privilege_id_id() { return MakeIndirectExec<true, true>(&has_function_privilege_id_id); }
+TExecFunc arrow_has_function_privilege_id_name() { return MakeIndirectExec<true, true>(&has_function_privilege_id_name); }
+TExecFunc arrow_has_function_privilege_name() { return MakeIndirectExec<true, true>(&has_function_privilege_name); }
+TExecFunc arrow_has_function_privilege_name_id() { return MakeIndirectExec<true, true>(&has_function_privilege_name_id); }
+TExecFunc arrow_has_function_privilege_name_name() { return MakeIndirectExec<true, true>(&has_function_privilege_name_name); }
+TExecFunc arrow_has_language_privilege_id() { return MakeIndirectExec<true, true>(&has_language_privilege_id); }
+TExecFunc arrow_has_language_privilege_id_id() { return MakeIndirectExec<true, true>(&has_language_privilege_id_id); }
+TExecFunc arrow_has_language_privilege_id_name() { return MakeIndirectExec<true, true>(&has_language_privilege_id_name); }
+TExecFunc arrow_has_language_privilege_name() { return MakeIndirectExec<true, true>(&has_language_privilege_name); }
+TExecFunc arrow_has_language_privilege_name_id() { return MakeIndirectExec<true, true>(&has_language_privilege_name_id); }
+TExecFunc arrow_has_language_privilege_name_name() { return MakeIndirectExec<true, true>(&has_language_privilege_name_name); }
+TExecFunc arrow_has_schema_privilege_id() { return MakeIndirectExec<true, true>(&has_schema_privilege_id); }
+TExecFunc arrow_has_schema_privilege_id_id() { return MakeIndirectExec<true, true>(&has_schema_privilege_id_id); }
+TExecFunc arrow_has_schema_privilege_id_name() { return MakeIndirectExec<true, true>(&has_schema_privilege_id_name); }
+TExecFunc arrow_has_schema_privilege_name() { return MakeIndirectExec<true, true>(&has_schema_privilege_name); }
+TExecFunc arrow_has_schema_privilege_name_id() { return MakeIndirectExec<true, true>(&has_schema_privilege_name_id); }
+TExecFunc arrow_has_schema_privilege_name_name() { return MakeIndirectExec<true, true>(&has_schema_privilege_name_name); }
+TExecFunc arrow_has_sequence_privilege_id() { return MakeIndirectExec<true, true>(&has_sequence_privilege_id); }
+TExecFunc arrow_has_sequence_privilege_id_id() { return MakeIndirectExec<true, true>(&has_sequence_privilege_id_id); }
+TExecFunc arrow_has_sequence_privilege_id_name() { return MakeIndirectExec<true, true>(&has_sequence_privilege_id_name); }
+TExecFunc arrow_has_sequence_privilege_name() { return MakeIndirectExec<true, true>(&has_sequence_privilege_name); }
+TExecFunc arrow_has_sequence_privilege_name_id() { return MakeIndirectExec<true, true>(&has_sequence_privilege_name_id); }
+TExecFunc arrow_has_sequence_privilege_name_name() { return MakeIndirectExec<true, true>(&has_sequence_privilege_name_name); }
+TExecFunc arrow_has_server_privilege_id() { return MakeIndirectExec<true, true>(&has_server_privilege_id); }
+TExecFunc arrow_has_server_privilege_id_id() { return MakeIndirectExec<true, true>(&has_server_privilege_id_id); }
+TExecFunc arrow_has_server_privilege_id_name() { return MakeIndirectExec<true, true>(&has_server_privilege_id_name); }
+TExecFunc arrow_has_server_privilege_name() { return MakeIndirectExec<true, true>(&has_server_privilege_name); }
+TExecFunc arrow_has_server_privilege_name_id() { return MakeIndirectExec<true, true>(&has_server_privilege_name_id); }
+TExecFunc arrow_has_server_privilege_name_name() { return MakeIndirectExec<true, true>(&has_server_privilege_name_name); }
+TExecFunc arrow_has_table_privilege_id() { return MakeIndirectExec<true, true>(&has_table_privilege_id); }
+TExecFunc arrow_has_table_privilege_id_id() { return MakeIndirectExec<true, true>(&has_table_privilege_id_id); }
+TExecFunc arrow_has_table_privilege_id_name() { return MakeIndirectExec<true, true>(&has_table_privilege_id_name); }
+TExecFunc arrow_has_table_privilege_name() { return MakeIndirectExec<true, true>(&has_table_privilege_name); }
+TExecFunc arrow_has_table_privilege_name_id() { return MakeIndirectExec<true, true>(&has_table_privilege_name_id); }
+TExecFunc arrow_has_table_privilege_name_name() { return MakeIndirectExec<true, true>(&has_table_privilege_name_name); }
+TExecFunc arrow_has_tablespace_privilege_id() { return MakeIndirectExec<true, true>(&has_tablespace_privilege_id); }
+TExecFunc arrow_has_tablespace_privilege_id_id() { return MakeIndirectExec<true, true>(&has_tablespace_privilege_id_id); }
+TExecFunc arrow_has_tablespace_privilege_id_name() { return MakeIndirectExec<true, true>(&has_tablespace_privilege_id_name); }
+TExecFunc arrow_has_tablespace_privilege_name() { return MakeIndirectExec<true, true>(&has_tablespace_privilege_name); }
+TExecFunc arrow_has_tablespace_privilege_name_id() { return MakeIndirectExec<true, true>(&has_tablespace_privilege_name_id); }
+TExecFunc arrow_has_tablespace_privilege_name_name() { return MakeIndirectExec<true, true>(&has_tablespace_privilege_name_name); }
+TExecFunc arrow_has_type_privilege_id() { return MakeIndirectExec<true, true>(&has_type_privilege_id); }
+TExecFunc arrow_has_type_privilege_id_id() { return MakeIndirectExec<true, true>(&has_type_privilege_id_id); }
+TExecFunc arrow_has_type_privilege_id_name() { return MakeIndirectExec<true, true>(&has_type_privilege_id_name); }
+TExecFunc arrow_has_type_privilege_name() { return MakeIndirectExec<true, true>(&has_type_privilege_name); }
+TExecFunc arrow_has_type_privilege_name_id() { return MakeIndirectExec<true, true>(&has_type_privilege_name_id); }
+TExecFunc arrow_has_type_privilege_name_name() { return MakeIndirectExec<true, true>(&has_type_privilege_name_name); }
+TExecFunc arrow_hash_aclitem() { return MakeIndirectExec<true, true>(&hash_aclitem); }
+TExecFunc arrow_hash_aclitem_extended() { return MakeIndirectExec<true, true>(&hash_aclitem_extended); }
+TExecFunc arrow_hash_array() { return MakeIndirectExec<true, true>(&hash_array); }
+TExecFunc arrow_hash_array_extended() { return MakeIndirectExec<true, true>(&hash_array_extended); }
+TExecFunc arrow_i2toi4() { return MakeIndirectExec<true, true>(&i2toi4); }
+TExecFunc arrow_i4toi2() { return MakeIndirectExec<true, true>(&i4toi2); }
+TExecFunc arrow_i8tod() { return MakeIndirectExec<true, true>(&i8tod); }
+TExecFunc arrow_i8tof() { return MakeIndirectExec<true, true>(&i8tof); }
+TExecFunc arrow_i8tooid() { return MakeIndirectExec<true, true>(&i8tooid); }
+TExecFunc arrow_in_range_date_interval() { return MakeIndirectExec<true, true>(&in_range_date_interval); }
+TExecFunc arrow_in_range_int2_int2() { return MakeIndirectExec<true, true>(&in_range_int2_int2); }
+TExecFunc arrow_in_range_int2_int4() { return MakeIndirectExec<true, true>(&in_range_int2_int4); }
+TExecFunc arrow_in_range_int2_int8() { return MakeIndirectExec<true, true>(&in_range_int2_int8); }
+TExecFunc arrow_in_range_int4_int2() { return MakeIndirectExec<true, true>(&in_range_int4_int2); }
+TExecFunc arrow_in_range_int4_int4() { return MakeIndirectExec<true, true>(&in_range_int4_int4); }
+TExecFunc arrow_in_range_int4_int8() { return MakeIndirectExec<true, true>(&in_range_int4_int8); }
+TExecFunc arrow_in_range_int8_int8() { return MakeIndirectExec<true, true>(&in_range_int8_int8); }
+TExecFunc arrow_in_range_time_interval() { return MakeIndirectExec<true, true>(&in_range_time_interval); }
+TExecFunc arrow_in_range_timetz_interval() { return MakeIndirectExec<true, true>(&in_range_timetz_interval); }
+TExecFunc arrow_inet_spg_choose() { return MakeIndirectExec<true, true>(&inet_spg_choose); }
+TExecFunc arrow_inet_spg_config() { return MakeIndirectExec<true, true>(&inet_spg_config); }
+TExecFunc arrow_inet_spg_inner_consistent() { return MakeIndirectExec<true, true>(&inet_spg_inner_consistent); }
+TExecFunc arrow_inet_spg_leaf_consistent() { return MakeIndirectExec<true, true>(&inet_spg_leaf_consistent); }
+TExecFunc arrow_inet_spg_picksplit() { return MakeIndirectExec<true, true>(&inet_spg_picksplit); }
+TExecFunc arrow_int24div() { return MakeIndirectExec<true, true>(&int24div); }
+TExecFunc arrow_int24eq() { return MakeIndirectExec<true, true>(&int24eq); }
+TExecFunc arrow_int24ge() { return MakeIndirectExec<true, true>(&int24ge); }
+TExecFunc arrow_int24gt() { return MakeIndirectExec<true, true>(&int24gt); }
+TExecFunc arrow_int24le() { return MakeIndirectExec<true, true>(&int24le); }
+TExecFunc arrow_int24lt() { return MakeIndirectExec<true, true>(&int24lt); }
+TExecFunc arrow_int24mi() { return MakeIndirectExec<true, true>(&int24mi); }
+TExecFunc arrow_int24mul() { return MakeIndirectExec<true, true>(&int24mul); }
+TExecFunc arrow_int24ne() { return MakeIndirectExec<true, true>(&int24ne); }
+TExecFunc arrow_int24pl() { return MakeIndirectExec<true, true>(&int24pl); }
+TExecFunc arrow_int28() { return MakeIndirectExec<true, true>(&int28); }
+TExecFunc arrow_int28div() { return MakeIndirectExec<true, true>(&int28div); }
+TExecFunc arrow_int28eq() { return MakeIndirectExec<true, true>(&int28eq); }
+TExecFunc arrow_int28ge() { return MakeIndirectExec<true, true>(&int28ge); }
+TExecFunc arrow_int28gt() { return MakeIndirectExec<true, true>(&int28gt); }
+TExecFunc arrow_int28le() { return MakeIndirectExec<true, true>(&int28le); }
+TExecFunc arrow_int28lt() { return MakeIndirectExec<true, true>(&int28lt); }
+TExecFunc arrow_int28mi() { return MakeIndirectExec<true, true>(&int28mi); }
+TExecFunc arrow_int28mul() { return MakeIndirectExec<true, true>(&int28mul); }
+TExecFunc arrow_int28ne() { return MakeIndirectExec<true, true>(&int28ne); }
+TExecFunc arrow_int28pl() { return MakeIndirectExec<true, true>(&int28pl); }
+TExecFunc arrow_int2abs() { return MakeIndirectExec<true, true>(&int2abs); }
+TExecFunc arrow_int2and() { return MakeIndirectExec<true, true>(&int2and); }
+TExecFunc arrow_int2div() { return MakeIndirectExec<true, true>(&int2div); }
+TExecFunc arrow_int2eq() { return MakeIndirectExec<true, true>(&int2eq); }
+TExecFunc arrow_int2ge() { return MakeIndirectExec<true, true>(&int2ge); }
+TExecFunc arrow_int2gt() { return MakeIndirectExec<true, true>(&int2gt); }
+TExecFunc arrow_int2in() { return MakeIndirectExec<true, true>(&int2in); }
+TExecFunc arrow_int2larger() { return MakeIndirectExec<true, true>(&int2larger); }
+TExecFunc arrow_int2le() { return MakeIndirectExec<true, true>(&int2le); }
+TExecFunc arrow_int2lt() { return MakeIndirectExec<true, true>(&int2lt); }
+TExecFunc arrow_int2mi() { return MakeIndirectExec<true, true>(&int2mi); }
+TExecFunc arrow_int2mod() { return MakeIndirectExec<true, true>(&int2mod); }
+TExecFunc arrow_int2mul() { return MakeIndirectExec<true, true>(&int2mul); }
+TExecFunc arrow_int2ne() { return MakeIndirectExec<true, true>(&int2ne); }
+TExecFunc arrow_int2not() { return MakeIndirectExec<true, true>(&int2not); }
+TExecFunc arrow_int2or() { return MakeIndirectExec<true, true>(&int2or); }
+TExecFunc arrow_int2out() { return MakeIndirectExec<true, false>(&int2out); }
+TExecFunc arrow_int2pl() { return MakeIndirectExec<true, true>(&int2pl); }
+TExecFunc arrow_int2recv() { return MakeIndirectExec<true, true>(&int2recv); }
+TExecFunc arrow_int2send() { return MakeIndirectExec<true, false>(&int2send); }
+TExecFunc arrow_int2shl() { return MakeIndirectExec<true, true>(&int2shl); }
+TExecFunc arrow_int2shr() { return MakeIndirectExec<true, true>(&int2shr); }
+TExecFunc arrow_int2smaller() { return MakeIndirectExec<true, true>(&int2smaller); }
+TExecFunc arrow_int2um() { return MakeIndirectExec<true, true>(&int2um); }
+TExecFunc arrow_int2up() { return MakeIndirectExec<true, true>(&int2up); }
+TExecFunc arrow_int2vectorin() { return MakeIndirectExec<true, false>(&int2vectorin); }
+TExecFunc arrow_int2vectorout() { return MakeIndirectExec<true, false>(&int2vectorout); }
+TExecFunc arrow_int2vectorrecv() { return MakeIndirectExec<true, false>(&int2vectorrecv); }
+TExecFunc arrow_int2vectorsend() { return MakeIndirectExec<true, false>(&int2vectorsend); }
+TExecFunc arrow_int2xor() { return MakeIndirectExec<true, true>(&int2xor); }
+TExecFunc arrow_int42div() { return MakeIndirectExec<true, true>(&int42div); }
+TExecFunc arrow_int42eq() { return MakeIndirectExec<true, true>(&int42eq); }
+TExecFunc arrow_int42ge() { return MakeIndirectExec<true, true>(&int42ge); }
+TExecFunc arrow_int42gt() { return MakeIndirectExec<true, true>(&int42gt); }
+TExecFunc arrow_int42le() { return MakeIndirectExec<true, true>(&int42le); }
+TExecFunc arrow_int42lt() { return MakeIndirectExec<true, true>(&int42lt); }
+TExecFunc arrow_int42mi() { return MakeIndirectExec<true, true>(&int42mi); }
+TExecFunc arrow_int42mul() { return MakeIndirectExec<true, true>(&int42mul); }
+TExecFunc arrow_int42ne() { return MakeIndirectExec<true, true>(&int42ne); }
+TExecFunc arrow_int42pl() { return MakeIndirectExec<true, true>(&int42pl); }
+TExecFunc arrow_int48() { return MakeIndirectExec<true, true>(&int48); }
+TExecFunc arrow_int48div() { return MakeIndirectExec<true, true>(&int48div); }
+TExecFunc arrow_int48eq() { return MakeIndirectExec<true, true>(&int48eq); }
+TExecFunc arrow_int48ge() { return MakeIndirectExec<true, true>(&int48ge); }
+TExecFunc arrow_int48gt() { return MakeIndirectExec<true, true>(&int48gt); }
+TExecFunc arrow_int48le() { return MakeIndirectExec<true, true>(&int48le); }
+TExecFunc arrow_int48lt() { return MakeIndirectExec<true, true>(&int48lt); }
+TExecFunc arrow_int48mi() { return MakeIndirectExec<true, true>(&int48mi); }
+TExecFunc arrow_int48mul() { return MakeIndirectExec<true, true>(&int48mul); }
+TExecFunc arrow_int48ne() { return MakeIndirectExec<true, true>(&int48ne); }
+TExecFunc arrow_int48pl() { return MakeIndirectExec<true, true>(&int48pl); }
+TExecFunc arrow_int4_bool() { return MakeIndirectExec<true, true>(&int4_bool); }
+TExecFunc arrow_int4abs() { return MakeIndirectExec<true, true>(&int4abs); }
+TExecFunc arrow_int4and() { return MakeIndirectExec<true, true>(&int4and); }
+TExecFunc arrow_int4div() { return MakeIndirectExec<true, true>(&int4div); }
+TExecFunc arrow_int4eq() { return MakeIndirectExec<true, true>(&int4eq); }
+TExecFunc arrow_int4gcd() { return MakeIndirectExec<true, true>(&int4gcd); }
+TExecFunc arrow_int4ge() { return MakeIndirectExec<true, true>(&int4ge); }
+TExecFunc arrow_int4gt() { return MakeIndirectExec<true, true>(&int4gt); }
+TExecFunc arrow_int4in() { return MakeIndirectExec<true, true>(&int4in); }
+TExecFunc arrow_int4inc() { return MakeIndirectExec<true, true>(&int4inc); }
+TExecFunc arrow_int4larger() { return MakeIndirectExec<true, true>(&int4larger); }
+TExecFunc arrow_int4lcm() { return MakeIndirectExec<true, true>(&int4lcm); }
+TExecFunc arrow_int4le() { return MakeIndirectExec<true, true>(&int4le); }
+TExecFunc arrow_int4lt() { return MakeIndirectExec<true, true>(&int4lt); }
+TExecFunc arrow_int4mi() { return MakeIndirectExec<true, true>(&int4mi); }
+TExecFunc arrow_int4mod() { return MakeIndirectExec<true, true>(&int4mod); }
+TExecFunc arrow_int4mul() { return MakeIndirectExec<true, true>(&int4mul); }
+TExecFunc arrow_int4ne() { return MakeIndirectExec<true, true>(&int4ne); }
+TExecFunc arrow_int4not() { return MakeIndirectExec<true, true>(&int4not); }
+TExecFunc arrow_int4or() { return MakeIndirectExec<true, true>(&int4or); }
+TExecFunc arrow_int4out() { return MakeIndirectExec<true, false>(&int4out); }
+TExecFunc arrow_int4pl() { return MakeIndirectExec<true, true>(&int4pl); }
+TExecFunc arrow_int4recv() { return MakeIndirectExec<true, true>(&int4recv); }
+TExecFunc arrow_int4send() { return MakeIndirectExec<true, false>(&int4send); }
+TExecFunc arrow_int4shl() { return MakeIndirectExec<true, true>(&int4shl); }
+TExecFunc arrow_int4shr() { return MakeIndirectExec<true, true>(&int4shr); }
+TExecFunc arrow_int4smaller() { return MakeIndirectExec<true, true>(&int4smaller); }
+TExecFunc arrow_int4um() { return MakeIndirectExec<true, true>(&int4um); }
+TExecFunc arrow_int4up() { return MakeIndirectExec<true, true>(&int4up); }
+TExecFunc arrow_int4xor() { return MakeIndirectExec<true, true>(&int4xor); }
+TExecFunc arrow_int82() { return MakeIndirectExec<true, true>(&int82); }
+TExecFunc arrow_int82div() { return MakeIndirectExec<true, true>(&int82div); }
+TExecFunc arrow_int82eq() { return MakeIndirectExec<true, true>(&int82eq); }
+TExecFunc arrow_int82ge() { return MakeIndirectExec<true, true>(&int82ge); }
+TExecFunc arrow_int82gt() { return MakeIndirectExec<true, true>(&int82gt); }
+TExecFunc arrow_int82le() { return MakeIndirectExec<true, true>(&int82le); }
+TExecFunc arrow_int82lt() { return MakeIndirectExec<true, true>(&int82lt); }
+TExecFunc arrow_int82mi() { return MakeIndirectExec<true, true>(&int82mi); }
+TExecFunc arrow_int82mul() { return MakeIndirectExec<true, true>(&int82mul); }
+TExecFunc arrow_int82ne() { return MakeIndirectExec<true, true>(&int82ne); }
+TExecFunc arrow_int82pl() { return MakeIndirectExec<true, true>(&int82pl); }
+TExecFunc arrow_int84() { return MakeIndirectExec<true, true>(&int84); }
+TExecFunc arrow_int84div() { return MakeIndirectExec<true, true>(&int84div); }
+TExecFunc arrow_int84eq() { return MakeIndirectExec<true, true>(&int84eq); }
+TExecFunc arrow_int84ge() { return MakeIndirectExec<true, true>(&int84ge); }
+TExecFunc arrow_int84gt() { return MakeIndirectExec<true, true>(&int84gt); }
+TExecFunc arrow_int84le() { return MakeIndirectExec<true, true>(&int84le); }
+TExecFunc arrow_int84lt() { return MakeIndirectExec<true, true>(&int84lt); }
+TExecFunc arrow_int84mi() { return MakeIndirectExec<true, true>(&int84mi); }
+TExecFunc arrow_int84mul() { return MakeIndirectExec<true, true>(&int84mul); }
+TExecFunc arrow_int84ne() { return MakeIndirectExec<true, true>(&int84ne); }
+TExecFunc arrow_int84pl() { return MakeIndirectExec<true, true>(&int84pl); }
+TExecFunc arrow_int8abs() { return MakeIndirectExec<true, true>(&int8abs); }
+TExecFunc arrow_int8and() { return MakeIndirectExec<true, true>(&int8and); }
+TExecFunc arrow_int8dec() { return MakeIndirectExec<true, true>(&int8dec); }
+TExecFunc arrow_int8dec_any() { return MakeIndirectExec<true, true>(&int8dec_any); }
+TExecFunc arrow_int8div() { return MakeIndirectExec<true, true>(&int8div); }
+TExecFunc arrow_int8eq() { return MakeIndirectExec<true, true>(&int8eq); }
+TExecFunc arrow_int8gcd() { return MakeIndirectExec<true, true>(&int8gcd); }
+TExecFunc arrow_int8ge() { return MakeIndirectExec<true, true>(&int8ge); }
+TExecFunc arrow_int8gt() { return MakeIndirectExec<true, true>(&int8gt); }
+TExecFunc arrow_int8in() { return MakeIndirectExec<true, true>(&int8in); }
+TExecFunc arrow_int8inc() { return MakeIndirectExec<true, true>(&int8inc); }
+TExecFunc arrow_int8inc_any() { return MakeIndirectExec<true, true>(&int8inc_any); }
+TExecFunc arrow_int8inc_float8_float8() { return MakeIndirectExec<true, true>(&int8inc_float8_float8); }
+TExecFunc arrow_int8larger() { return MakeIndirectExec<true, true>(&int8larger); }
+TExecFunc arrow_int8lcm() { return MakeIndirectExec<true, true>(&int8lcm); }
+TExecFunc arrow_int8le() { return MakeIndirectExec<true, true>(&int8le); }
+TExecFunc arrow_int8lt() { return MakeIndirectExec<true, true>(&int8lt); }
+TExecFunc arrow_int8mi() { return MakeIndirectExec<true, true>(&int8mi); }
+TExecFunc arrow_int8mod() { return MakeIndirectExec<true, true>(&int8mod); }
+TExecFunc arrow_int8mul() { return MakeIndirectExec<true, true>(&int8mul); }
+TExecFunc arrow_int8ne() { return MakeIndirectExec<true, true>(&int8ne); }
+TExecFunc arrow_int8not() { return MakeIndirectExec<true, true>(&int8not); }
+TExecFunc arrow_int8or() { return MakeIndirectExec<true, true>(&int8or); }
+TExecFunc arrow_int8out() { return MakeIndirectExec<true, false>(&int8out); }
+TExecFunc arrow_int8pl() { return MakeIndirectExec<true, true>(&int8pl); }
+TExecFunc arrow_int8recv() { return MakeIndirectExec<true, true>(&int8recv); }
+TExecFunc arrow_int8send() { return MakeIndirectExec<true, false>(&int8send); }
+TExecFunc arrow_int8shl() { return MakeIndirectExec<true, true>(&int8shl); }
+TExecFunc arrow_int8shr() { return MakeIndirectExec<true, true>(&int8shr); }
+TExecFunc arrow_int8smaller() { return MakeIndirectExec<true, true>(&int8smaller); }
+TExecFunc arrow_int8um() { return MakeIndirectExec<true, true>(&int8um); }
+TExecFunc arrow_int8up() { return MakeIndirectExec<true, true>(&int8up); }
+TExecFunc arrow_int8xor() { return MakeIndirectExec<true, true>(&int8xor); }
+TExecFunc arrow_interval_time() { return MakeIndirectExec<true, true>(&interval_time); }
+TExecFunc arrow_json_string_to_tsvector() { return MakeIndirectExec<true, false>(&json_string_to_tsvector); }
+TExecFunc arrow_json_string_to_tsvector_byid() { return MakeIndirectExec<true, false>(&json_string_to_tsvector_byid); }
+TExecFunc arrow_json_to_tsvector() { return MakeIndirectExec<true, false>(&json_to_tsvector); }
+TExecFunc arrow_json_to_tsvector_byid() { return MakeIndirectExec<true, false>(&json_to_tsvector_byid); }
+TExecFunc arrow_jsonb_cmp() { return MakeIndirectExec<true, true>(&jsonb_cmp); }
+TExecFunc arrow_jsonb_contained() { return MakeIndirectExec<true, true>(&jsonb_contained); }
+TExecFunc arrow_jsonb_contains() { return MakeIndirectExec<true, true>(&jsonb_contains); }
+TExecFunc arrow_jsonb_eq() { return MakeIndirectExec<true, true>(&jsonb_eq); }
+TExecFunc arrow_jsonb_exists() { return MakeIndirectExec<true, true>(&jsonb_exists); }
+TExecFunc arrow_jsonb_exists_all() { return MakeIndirectExec<true, true>(&jsonb_exists_all); }
+TExecFunc arrow_jsonb_exists_any() { return MakeIndirectExec<true, true>(&jsonb_exists_any); }
+TExecFunc arrow_jsonb_ge() { return MakeIndirectExec<true, true>(&jsonb_ge); }
+TExecFunc arrow_jsonb_gt() { return MakeIndirectExec<true, true>(&jsonb_gt); }
+TExecFunc arrow_jsonb_hash() { return MakeIndirectExec<true, true>(&jsonb_hash); }
+TExecFunc arrow_jsonb_hash_extended() { return MakeIndirectExec<true, true>(&jsonb_hash_extended); }
+TExecFunc arrow_jsonb_le() { return MakeIndirectExec<true, true>(&jsonb_le); }
+TExecFunc arrow_jsonb_lt() { return MakeIndirectExec<true, true>(&jsonb_lt); }
+TExecFunc arrow_jsonb_ne() { return MakeIndirectExec<true, true>(&jsonb_ne); }
+TExecFunc arrow_jsonb_path_exists() { return MakeIndirectExec<true, true>(&jsonb_path_exists); }
+TExecFunc arrow_jsonb_path_exists_opr() { return MakeIndirectExec<true, true>(&jsonb_path_exists_opr); }
+TExecFunc arrow_jsonb_path_exists_tz() { return MakeIndirectExec<true, true>(&jsonb_path_exists_tz); }
+TExecFunc arrow_jsonb_path_match() { return MakeIndirectExec<true, true>(&jsonb_path_match); }
+TExecFunc arrow_jsonb_path_match_opr() { return MakeIndirectExec<true, true>(&jsonb_path_match_opr); }
+TExecFunc arrow_jsonb_path_match_tz() { return MakeIndirectExec<true, true>(&jsonb_path_match_tz); }
+TExecFunc arrow_jsonb_path_query_array() { return MakeIndirectExec<true, false>(&jsonb_path_query_array); }
+TExecFunc arrow_jsonb_path_query_array_tz() { return MakeIndirectExec<true, false>(&jsonb_path_query_array_tz); }
+TExecFunc arrow_jsonb_path_query_first() { return MakeIndirectExec<true, false>(&jsonb_path_query_first); }
+TExecFunc arrow_jsonb_path_query_first_tz() { return MakeIndirectExec<true, false>(&jsonb_path_query_first_tz); }
+TExecFunc arrow_jsonb_string_to_tsvector() { return MakeIndirectExec<true, false>(&jsonb_string_to_tsvector); }
+TExecFunc arrow_jsonb_string_to_tsvector_byid() { return MakeIndirectExec<true, false>(&jsonb_string_to_tsvector_byid); }
+TExecFunc arrow_jsonb_to_tsvector() { return MakeIndirectExec<true, false>(&jsonb_to_tsvector); }
+TExecFunc arrow_jsonb_to_tsvector_byid() { return MakeIndirectExec<true, false>(&jsonb_to_tsvector_byid); }
+TExecFunc arrow_make_date() { return MakeIndirectExec<true, true>(&make_date); }
+TExecFunc arrow_make_time() { return MakeIndirectExec<true, true>(&make_time); }
+TExecFunc arrow_makeaclitem() { return MakeIndirectExec<true, false>(&makeaclitem); }
+TExecFunc arrow_multirange_gist_compress() { return MakeIndirectExec<true, true>(&multirange_gist_compress); }
+TExecFunc arrow_multirange_gist_consistent() { return MakeIndirectExec<true, true>(&multirange_gist_consistent); }
+TExecFunc arrow_multirange_typanalyze() { return MakeIndirectExec<true, true>(&multirange_typanalyze); }
+TExecFunc arrow_name_text() { return MakeIndirectExec<true, false>(&name_text); }
+TExecFunc arrow_nameeqtext() { return MakeIndirectExec<true, true>(&nameeqtext); }
+TExecFunc arrow_namegetext() { return MakeIndirectExec<true, true>(&namegetext); }
+TExecFunc arrow_namegttext() { return MakeIndirectExec<true, true>(&namegttext); }
+TExecFunc arrow_nameletext() { return MakeIndirectExec<true, true>(&nameletext); }
+TExecFunc arrow_namelttext() { return MakeIndirectExec<true, true>(&namelttext); }
+TExecFunc arrow_namenetext() { return MakeIndirectExec<true, true>(&namenetext); }
+TExecFunc arrow_oidtoi8() { return MakeIndirectExec<true, true>(&oidtoi8); }
+TExecFunc arrow_overlaps_time() { return MakeIndirectExec<false, true>(&overlaps_time); }
+TExecFunc arrow_overlaps_timetz() { return MakeIndirectExec<false, true>(&overlaps_timetz); }
+TExecFunc arrow_pg_advisory_lock_int4() { return MakeIndirectExec<true, true>(&pg_advisory_lock_int4); }
+TExecFunc arrow_pg_advisory_lock_int8() { return MakeIndirectExec<true, true>(&pg_advisory_lock_int8); }
+TExecFunc arrow_pg_advisory_lock_shared_int4() { return MakeIndirectExec<true, true>(&pg_advisory_lock_shared_int4); }
+TExecFunc arrow_pg_advisory_lock_shared_int8() { return MakeIndirectExec<true, true>(&pg_advisory_lock_shared_int8); }
+TExecFunc arrow_pg_advisory_unlock_all() { return MakeIndirectExec<true, true>(&pg_advisory_unlock_all); }
+TExecFunc arrow_pg_advisory_unlock_int4() { return MakeIndirectExec<true, true>(&pg_advisory_unlock_int4); }
+TExecFunc arrow_pg_advisory_unlock_int8() { return MakeIndirectExec<true, true>(&pg_advisory_unlock_int8); }
+TExecFunc arrow_pg_advisory_unlock_shared_int4() { return MakeIndirectExec<true, true>(&pg_advisory_unlock_shared_int4); }
+TExecFunc arrow_pg_advisory_unlock_shared_int8() { return MakeIndirectExec<true, true>(&pg_advisory_unlock_shared_int8); }
+TExecFunc arrow_pg_advisory_xact_lock_int4() { return MakeIndirectExec<true, true>(&pg_advisory_xact_lock_int4); }
+TExecFunc arrow_pg_advisory_xact_lock_int8() { return MakeIndirectExec<true, true>(&pg_advisory_xact_lock_int8); }
+TExecFunc arrow_pg_advisory_xact_lock_shared_int4() { return MakeIndirectExec<true, true>(&pg_advisory_xact_lock_shared_int4); }
+TExecFunc arrow_pg_advisory_xact_lock_shared_int8() { return MakeIndirectExec<true, true>(&pg_advisory_xact_lock_shared_int8); }
+TExecFunc arrow_pg_blocking_pids() { return MakeIndirectExec<true, false>(&pg_blocking_pids); }
+TExecFunc arrow_pg_collation_actual_version() { return MakeIndirectExec<true, false>(&pg_collation_actual_version); }
+TExecFunc arrow_pg_column_compression() { return MakeIndirectExec<true, false>(&pg_column_compression); }
+TExecFunc arrow_pg_column_size() { return MakeIndirectExec<true, true>(&pg_column_size); }
+TExecFunc arrow_pg_dependencies_in() { return MakeIndirectExec<true, false>(&pg_dependencies_in); }
+TExecFunc arrow_pg_dependencies_out() { return MakeIndirectExec<true, false>(&pg_dependencies_out); }
+TExecFunc arrow_pg_dependencies_recv() { return MakeIndirectExec<true, false>(&pg_dependencies_recv); }
+TExecFunc arrow_pg_dependencies_send() { return MakeIndirectExec<true, false>(&pg_dependencies_send); }
+TExecFunc arrow_pg_event_trigger_table_rewrite_oid() { return MakeIndirectExec<true, true>(&pg_event_trigger_table_rewrite_oid); }
+TExecFunc arrow_pg_event_trigger_table_rewrite_reason() { return MakeIndirectExec<true, true>(&pg_event_trigger_table_rewrite_reason); }
+TExecFunc arrow_pg_has_role_id() { return MakeIndirectExec<true, true>(&pg_has_role_id); }
+TExecFunc arrow_pg_has_role_id_id() { return MakeIndirectExec<true, true>(&pg_has_role_id_id); }
+TExecFunc arrow_pg_has_role_id_name() { return MakeIndirectExec<true, true>(&pg_has_role_id_name); }
+TExecFunc arrow_pg_has_role_name() { return MakeIndirectExec<true, true>(&pg_has_role_name); }
+TExecFunc arrow_pg_has_role_name_id() { return MakeIndirectExec<true, true>(&pg_has_role_name_id); }
+TExecFunc arrow_pg_has_role_name_name() { return MakeIndirectExec<true, true>(&pg_has_role_name_name); }
+TExecFunc arrow_pg_import_system_collations() { return MakeIndirectExec<true, true>(&pg_import_system_collations); }
+TExecFunc arrow_pg_isolation_test_session_is_blocked() { return MakeIndirectExec<true, true>(&pg_isolation_test_session_is_blocked); }
+TExecFunc arrow_pg_logical_emit_message_bytea() { return MakeIndirectExec<true, true>(&pg_logical_emit_message_bytea); }
+TExecFunc arrow_pg_logical_emit_message_text() { return MakeIndirectExec<true, true>(&pg_logical_emit_message_text); }
+TExecFunc arrow_pg_mcv_list_in() { return MakeIndirectExec<true, false>(&pg_mcv_list_in); }
+TExecFunc arrow_pg_mcv_list_out() { return MakeIndirectExec<true, false>(&pg_mcv_list_out); }
+TExecFunc arrow_pg_mcv_list_recv() { return MakeIndirectExec<true, false>(&pg_mcv_list_recv); }
+TExecFunc arrow_pg_mcv_list_send() { return MakeIndirectExec<true, false>(&pg_mcv_list_send); }
+TExecFunc arrow_pg_notification_queue_usage() { return MakeIndirectExec<true, true>(&pg_notification_queue_usage); }
+TExecFunc arrow_pg_notify() { return MakeIndirectExec<false, true>(&pg_notify); }
+TExecFunc arrow_pg_relation_is_publishable() { return MakeIndirectExec<true, true>(&pg_relation_is_publishable); }
+TExecFunc arrow_pg_safe_snapshot_blocking_pids() { return MakeIndirectExec<true, false>(&pg_safe_snapshot_blocking_pids); }
+TExecFunc arrow_pg_stat_get_wal_receiver() { return MakeIndirectExec<false, false>(&pg_stat_get_wal_receiver); }
+TExecFunc arrow_pg_try_advisory_lock_int4() { return MakeIndirectExec<true, true>(&pg_try_advisory_lock_int4); }
+TExecFunc arrow_pg_try_advisory_lock_int8() { return MakeIndirectExec<true, true>(&pg_try_advisory_lock_int8); }
+TExecFunc arrow_pg_try_advisory_lock_shared_int4() { return MakeIndirectExec<true, true>(&pg_try_advisory_lock_shared_int4); }
+TExecFunc arrow_pg_try_advisory_lock_shared_int8() { return MakeIndirectExec<true, true>(&pg_try_advisory_lock_shared_int8); }
+TExecFunc arrow_pg_try_advisory_xact_lock_int4() { return MakeIndirectExec<true, true>(&pg_try_advisory_xact_lock_int4); }
+TExecFunc arrow_pg_try_advisory_xact_lock_int8() { return MakeIndirectExec<true, true>(&pg_try_advisory_xact_lock_int8); }
+TExecFunc arrow_pg_try_advisory_xact_lock_shared_int4() { return MakeIndirectExec<true, true>(&pg_try_advisory_xact_lock_shared_int4); }
+TExecFunc arrow_pg_try_advisory_xact_lock_shared_int8() { return MakeIndirectExec<true, true>(&pg_try_advisory_xact_lock_shared_int8); }
+TExecFunc arrow_phraseto_tsquery() { return MakeIndirectExec<true, false>(&phraseto_tsquery); }
+TExecFunc arrow_phraseto_tsquery_byid() { return MakeIndirectExec<true, false>(&phraseto_tsquery_byid); }
+TExecFunc arrow_plainto_tsquery() { return MakeIndirectExec<true, false>(&plainto_tsquery); }
+TExecFunc arrow_plainto_tsquery_byid() { return MakeIndirectExec<true, false>(&plainto_tsquery_byid); }
+TExecFunc arrow_query_to_xml() { return MakeIndirectExec<true, false>(&query_to_xml); }
+TExecFunc arrow_query_to_xml_and_xmlschema() { return MakeIndirectExec<true, false>(&query_to_xml_and_xmlschema); }
+TExecFunc arrow_query_to_xmlschema() { return MakeIndirectExec<true, false>(&query_to_xmlschema); }
+TExecFunc arrow_range_gist_consistent() { return MakeIndirectExec<true, true>(&range_gist_consistent); }
+TExecFunc arrow_range_gist_penalty() { return MakeIndirectExec<true, true>(&range_gist_penalty); }
+TExecFunc arrow_range_gist_picksplit() { return MakeIndirectExec<true, true>(&range_gist_picksplit); }
+TExecFunc arrow_range_gist_same() { return MakeIndirectExec<true, true>(&range_gist_same); }
+TExecFunc arrow_range_gist_union() { return MakeIndirectExec<true, false>(&range_gist_union); }
+TExecFunc arrow_range_typanalyze() { return MakeIndirectExec<true, true>(&range_typanalyze); }
+TExecFunc arrow_replace_text() { return MakeIndirectExec<true, false>(&replace_text); }
+TExecFunc arrow_schema_to_xml() { return MakeIndirectExec<true, false>(&schema_to_xml); }
+TExecFunc arrow_schema_to_xml_and_xmlschema() { return MakeIndirectExec<true, false>(&schema_to_xml_and_xmlschema); }
+TExecFunc arrow_schema_to_xmlschema() { return MakeIndirectExec<true, false>(&schema_to_xmlschema); }
+TExecFunc arrow_spg_range_quad_choose() { return MakeIndirectExec<true, true>(&spg_range_quad_choose); }
+TExecFunc arrow_spg_range_quad_config() { return MakeIndirectExec<true, true>(&spg_range_quad_config); }
+TExecFunc arrow_spg_range_quad_inner_consistent() { return MakeIndirectExec<true, true>(&spg_range_quad_inner_consistent); }
+TExecFunc arrow_spg_range_quad_leaf_consistent() { return MakeIndirectExec<true, true>(&spg_range_quad_leaf_consistent); }
+TExecFunc arrow_spg_range_quad_picksplit() { return MakeIndirectExec<true, true>(&spg_range_quad_picksplit); }
+TExecFunc arrow_split_part() { return MakeIndirectExec<true, false>(&split_part); }
+TExecFunc arrow_string_agg_finalfn() { return MakeIndirectExec<false, false>(&string_agg_finalfn); }
+TExecFunc arrow_string_agg_transfn() { return MakeIndirectExec<false, true>(&string_agg_transfn); }
+TExecFunc arrow_table_to_xml() { return MakeIndirectExec<true, false>(&table_to_xml); }
+TExecFunc arrow_table_to_xml_and_xmlschema() { return MakeIndirectExec<true, false>(&table_to_xml_and_xmlschema); }
+TExecFunc arrow_table_to_xmlschema() { return MakeIndirectExec<true, false>(&table_to_xmlschema); }
+TExecFunc arrow_text_format_nv() { return MakeIndirectExec<false, false>(&text_format_nv); }
+TExecFunc arrow_text_ge() { return MakeIndirectExec<true, true>(&text_ge); }
+TExecFunc arrow_text_gt() { return MakeIndirectExec<true, true>(&text_gt); }
+TExecFunc arrow_text_larger() { return MakeIndirectExec<true, false>(&text_larger); }
+TExecFunc arrow_text_le() { return MakeIndirectExec<true, true>(&text_le); }
+TExecFunc arrow_text_left() { return MakeIndirectExec<true, false>(&text_left); }
+TExecFunc arrow_text_lt() { return MakeIndirectExec<true, true>(&text_lt); }
+TExecFunc arrow_text_name() { return MakeIndirectExec<true, false>(&text_name); }
+TExecFunc arrow_text_pattern_ge() { return MakeIndirectExec<true, true>(&text_pattern_ge); }
+TExecFunc arrow_text_pattern_gt() { return MakeIndirectExec<true, true>(&text_pattern_gt); }
+TExecFunc arrow_text_pattern_le() { return MakeIndirectExec<true, true>(&text_pattern_le); }
+TExecFunc arrow_text_pattern_lt() { return MakeIndirectExec<true, true>(&text_pattern_lt); }
+TExecFunc arrow_text_reverse() { return MakeIndirectExec<true, false>(&text_reverse); }
+TExecFunc arrow_text_right() { return MakeIndirectExec<true, false>(&text_right); }
+TExecFunc arrow_text_smaller() { return MakeIndirectExec<true, false>(&text_smaller); }
+TExecFunc arrow_text_starts_with() { return MakeIndirectExec<true, true>(&text_starts_with); }
+TExecFunc arrow_text_substr() { return MakeIndirectExec<true, false>(&text_substr); }
+TExecFunc arrow_text_substr_no_len() { return MakeIndirectExec<true, false>(&text_substr_no_len); }
+TExecFunc arrow_text_to_array() { return MakeIndirectExec<false, false>(&text_to_array); }
+TExecFunc arrow_text_to_array_null() { return MakeIndirectExec<false, false>(&text_to_array_null); }
+TExecFunc arrow_textcat() { return MakeIndirectExec<true, false>(&textcat); }
+TExecFunc arrow_texteq() { return MakeIndirectExec<true, true>(&texteq); }
+TExecFunc arrow_texteqname() { return MakeIndirectExec<true, true>(&texteqname); }
+TExecFunc arrow_textgename() { return MakeIndirectExec<true, true>(&textgename); }
+TExecFunc arrow_textgtname() { return MakeIndirectExec<true, true>(&textgtname); }
+TExecFunc arrow_textin() { return MakeIndirectExec<true, false>(&textin); }
+TExecFunc arrow_textlen() { return MakeIndirectExec<true, true>(&textlen); }
+TExecFunc arrow_textlename() { return MakeIndirectExec<true, true>(&textlename); }
+TExecFunc arrow_textltname() { return MakeIndirectExec<true, true>(&textltname); }
+TExecFunc arrow_textne() { return MakeIndirectExec<true, true>(&textne); }
+TExecFunc arrow_textnename() { return MakeIndirectExec<true, true>(&textnename); }
+TExecFunc arrow_textoctetlen() { return MakeIndirectExec<true, true>(&textoctetlen); }
+TExecFunc arrow_textout() { return MakeIndirectExec<true, false>(&textout); }
+TExecFunc arrow_textoverlay() { return MakeIndirectExec<true, false>(&textoverlay); }
+TExecFunc arrow_textoverlay_no_len() { return MakeIndirectExec<true, false>(&textoverlay_no_len); }
+TExecFunc arrow_textpos() { return MakeIndirectExec<true, true>(&textpos); }
+TExecFunc arrow_textrecv() { return MakeIndirectExec<true, false>(&textrecv); }
+TExecFunc arrow_textsend() { return MakeIndirectExec<true, false>(&textsend); }
+TExecFunc arrow_texttoxml() { return MakeIndirectExec<true, false>(&texttoxml); }
+TExecFunc arrow_time_cmp() { return MakeIndirectExec<true, true>(&time_cmp); }
+TExecFunc arrow_time_eq() { return MakeIndirectExec<true, true>(&time_eq); }
+TExecFunc arrow_time_ge() { return MakeIndirectExec<true, true>(&time_ge); }
+TExecFunc arrow_time_gt() { return MakeIndirectExec<true, true>(&time_gt); }
+TExecFunc arrow_time_hash() { return MakeIndirectExec<true, true>(&time_hash); }
+TExecFunc arrow_time_hash_extended() { return MakeIndirectExec<true, true>(&time_hash_extended); }
+TExecFunc arrow_time_in() { return MakeIndirectExec<true, true>(&time_in); }
+TExecFunc arrow_time_interval() { return MakeIndirectExec<true, false>(&time_interval); }
+TExecFunc arrow_time_larger() { return MakeIndirectExec<true, true>(&time_larger); }
+TExecFunc arrow_time_le() { return MakeIndirectExec<true, true>(&time_le); }
+TExecFunc arrow_time_lt() { return MakeIndirectExec<true, true>(&time_lt); }
+TExecFunc arrow_time_mi_interval() { return MakeIndirectExec<true, true>(&time_mi_interval); }
+TExecFunc arrow_time_mi_time() { return MakeIndirectExec<true, false>(&time_mi_time); }
+TExecFunc arrow_time_ne() { return MakeIndirectExec<true, true>(&time_ne); }
+TExecFunc arrow_time_out() { return MakeIndirectExec<true, false>(&time_out); }
+TExecFunc arrow_time_part() { return MakeIndirectExec<true, true>(&time_part); }
+TExecFunc arrow_time_pl_interval() { return MakeIndirectExec<true, true>(&time_pl_interval); }
+TExecFunc arrow_time_recv() { return MakeIndirectExec<true, true>(&time_recv); }
+TExecFunc arrow_time_scale() { return MakeIndirectExec<true, true>(&time_scale); }
+TExecFunc arrow_time_send() { return MakeIndirectExec<true, false>(&time_send); }
+TExecFunc arrow_time_smaller() { return MakeIndirectExec<true, true>(&time_smaller); }
+TExecFunc arrow_time_support() { return MakeIndirectExec<true, true>(&time_support); }
+TExecFunc arrow_time_timetz() { return MakeIndirectExec<true, false>(&time_timetz); }
+TExecFunc arrow_timestamp_cmp_date() { return MakeIndirectExec<true, true>(&timestamp_cmp_date); }
+TExecFunc arrow_timestamp_date() { return MakeIndirectExec<true, true>(&timestamp_date); }
+TExecFunc arrow_timestamp_eq_date() { return MakeIndirectExec<true, true>(&timestamp_eq_date); }
+TExecFunc arrow_timestamp_ge_date() { return MakeIndirectExec<true, true>(&timestamp_ge_date); }
+TExecFunc arrow_timestamp_gt_date() { return MakeIndirectExec<true, true>(&timestamp_gt_date); }
+TExecFunc arrow_timestamp_le_date() { return MakeIndirectExec<true, true>(&timestamp_le_date); }
+TExecFunc arrow_timestamp_lt_date() { return MakeIndirectExec<true, true>(&timestamp_lt_date); }
+TExecFunc arrow_timestamp_ne_date() { return MakeIndirectExec<true, true>(&timestamp_ne_date); }
+TExecFunc arrow_timestamp_time() { return MakeIndirectExec<true, true>(&timestamp_time); }
+TExecFunc arrow_timestamptz_cmp_date() { return MakeIndirectExec<true, true>(&timestamptz_cmp_date); }
+TExecFunc arrow_timestamptz_date() { return MakeIndirectExec<true, true>(&timestamptz_date); }
+TExecFunc arrow_timestamptz_eq_date() { return MakeIndirectExec<true, true>(&timestamptz_eq_date); }
+TExecFunc arrow_timestamptz_ge_date() { return MakeIndirectExec<true, true>(&timestamptz_ge_date); }
+TExecFunc arrow_timestamptz_gt_date() { return MakeIndirectExec<true, true>(&timestamptz_gt_date); }
+TExecFunc arrow_timestamptz_le_date() { return MakeIndirectExec<true, true>(&timestamptz_le_date); }
+TExecFunc arrow_timestamptz_lt_date() { return MakeIndirectExec<true, true>(&timestamptz_lt_date); }
+TExecFunc arrow_timestamptz_ne_date() { return MakeIndirectExec<true, true>(&timestamptz_ne_date); }
+TExecFunc arrow_timestamptz_time() { return MakeIndirectExec<true, true>(&timestamptz_time); }
+TExecFunc arrow_timestamptz_timetz() { return MakeIndirectExec<true, false>(&timestamptz_timetz); }
+TExecFunc arrow_timetypmodin() { return MakeIndirectExec<true, true>(&timetypmodin); }
+TExecFunc arrow_timetypmodout() { return MakeIndirectExec<true, false>(&timetypmodout); }
+TExecFunc arrow_timetz_cmp() { return MakeIndirectExec<true, true>(&timetz_cmp); }
+TExecFunc arrow_timetz_eq() { return MakeIndirectExec<true, true>(&timetz_eq); }
+TExecFunc arrow_timetz_ge() { return MakeIndirectExec<true, true>(&timetz_ge); }
+TExecFunc arrow_timetz_gt() { return MakeIndirectExec<true, true>(&timetz_gt); }
+TExecFunc arrow_timetz_hash() { return MakeIndirectExec<true, true>(&timetz_hash); }
+TExecFunc arrow_timetz_hash_extended() { return MakeIndirectExec<true, true>(&timetz_hash_extended); }
+TExecFunc arrow_timetz_in() { return MakeIndirectExec<true, false>(&timetz_in); }
+TExecFunc arrow_timetz_izone() { return MakeIndirectExec<true, false>(&timetz_izone); }
+TExecFunc arrow_timetz_larger() { return MakeIndirectExec<true, false>(&timetz_larger); }
+TExecFunc arrow_timetz_le() { return MakeIndirectExec<true, true>(&timetz_le); }
+TExecFunc arrow_timetz_lt() { return MakeIndirectExec<true, true>(&timetz_lt); }
+TExecFunc arrow_timetz_mi_interval() { return MakeIndirectExec<true, false>(&timetz_mi_interval); }
+TExecFunc arrow_timetz_ne() { return MakeIndirectExec<true, true>(&timetz_ne); }
+TExecFunc arrow_timetz_out() { return MakeIndirectExec<true, false>(&timetz_out); }
+TExecFunc arrow_timetz_part() { return MakeIndirectExec<true, true>(&timetz_part); }
+TExecFunc arrow_timetz_pl_interval() { return MakeIndirectExec<true, false>(&timetz_pl_interval); }
+TExecFunc arrow_timetz_recv() { return MakeIndirectExec<true, false>(&timetz_recv); }
+TExecFunc arrow_timetz_scale() { return MakeIndirectExec<true, false>(&timetz_scale); }
+TExecFunc arrow_timetz_send() { return MakeIndirectExec<true, false>(&timetz_send); }
+TExecFunc arrow_timetz_smaller() { return MakeIndirectExec<true, false>(&timetz_smaller); }
+TExecFunc arrow_timetz_time() { return MakeIndirectExec<true, true>(&timetz_time); }
+TExecFunc arrow_timetz_zone() { return MakeIndirectExec<true, false>(&timetz_zone); }
+TExecFunc arrow_timetztypmodin() { return MakeIndirectExec<true, true>(&timetztypmodin); }
+TExecFunc arrow_timetztypmodout() { return MakeIndirectExec<true, false>(&timetztypmodout); }
+TExecFunc arrow_to_hex32() { return MakeIndirectExec<true, false>(&to_hex32); }
+TExecFunc arrow_to_hex64() { return MakeIndirectExec<true, false>(&to_hex64); }
+TExecFunc arrow_to_tsquery() { return MakeIndirectExec<true, false>(&to_tsquery); }
+TExecFunc arrow_to_tsquery_byid() { return MakeIndirectExec<true, false>(&to_tsquery_byid); }
+TExecFunc arrow_to_tsvector() { return MakeIndirectExec<true, false>(&to_tsvector); }
+TExecFunc arrow_to_tsvector_byid() { return MakeIndirectExec<true, false>(&to_tsvector_byid); }
+TExecFunc arrow_trim_array() { return MakeIndirectExec<true, false>(&trim_array); }
+TExecFunc arrow_ts_headline() { return MakeIndirectExec<true, false>(&ts_headline); }
+TExecFunc arrow_ts_headline_byid() { return MakeIndirectExec<true, false>(&ts_headline_byid); }
+TExecFunc arrow_ts_headline_byid_opt() { return MakeIndirectExec<true, false>(&ts_headline_byid_opt); }
+TExecFunc arrow_ts_headline_json() { return MakeIndirectExec<true, false>(&ts_headline_json); }
+TExecFunc arrow_ts_headline_json_byid() { return MakeIndirectExec<true, false>(&ts_headline_json_byid); }
+TExecFunc arrow_ts_headline_json_byid_opt() { return MakeIndirectExec<true, false>(&ts_headline_json_byid_opt); }
+TExecFunc arrow_ts_headline_json_opt() { return MakeIndirectExec<true, false>(&ts_headline_json_opt); }
+TExecFunc arrow_ts_headline_jsonb() { return MakeIndirectExec<true, false>(&ts_headline_jsonb); }
+TExecFunc arrow_ts_headline_jsonb_byid() { return MakeIndirectExec<true, false>(&ts_headline_jsonb_byid); }
+TExecFunc arrow_ts_headline_jsonb_byid_opt() { return MakeIndirectExec<true, false>(&ts_headline_jsonb_byid_opt); }
+TExecFunc arrow_ts_headline_jsonb_opt() { return MakeIndirectExec<true, false>(&ts_headline_jsonb_opt); }
+TExecFunc arrow_ts_headline_opt() { return MakeIndirectExec<true, false>(&ts_headline_opt); }
+TExecFunc arrow_ts_match_qv() { return MakeIndirectExec<true, true>(&ts_match_qv); }
+TExecFunc arrow_ts_match_tq() { return MakeIndirectExec<true, true>(&ts_match_tq); }
+TExecFunc arrow_ts_match_tt() { return MakeIndirectExec<true, true>(&ts_match_tt); }
+TExecFunc arrow_ts_match_vq() { return MakeIndirectExec<true, true>(&ts_match_vq); }
+TExecFunc arrow_ts_rank_tt() { return MakeIndirectExec<true, true>(&ts_rank_tt); }
+TExecFunc arrow_ts_rank_ttf() { return MakeIndirectExec<true, true>(&ts_rank_ttf); }
+TExecFunc arrow_ts_rank_wtt() { return MakeIndirectExec<true, true>(&ts_rank_wtt); }
+TExecFunc arrow_ts_rank_wttf() { return MakeIndirectExec<true, true>(&ts_rank_wttf); }
+TExecFunc arrow_ts_rankcd_tt() { return MakeIndirectExec<true, true>(&ts_rankcd_tt); }
+TExecFunc arrow_ts_rankcd_ttf() { return MakeIndirectExec<true, true>(&ts_rankcd_ttf); }
+TExecFunc arrow_ts_rankcd_wtt() { return MakeIndirectExec<true, true>(&ts_rankcd_wtt); }
+TExecFunc arrow_ts_rankcd_wttf() { return MakeIndirectExec<true, true>(&ts_rankcd_wttf); }
+TExecFunc arrow_tsvector_cmp() { return MakeIndirectExec<true, true>(&tsvector_cmp); }
+TExecFunc arrow_tsvector_concat() { return MakeIndirectExec<true, false>(&tsvector_concat); }
+TExecFunc arrow_tsvector_delete_arr() { return MakeIndirectExec<true, false>(&tsvector_delete_arr); }
+TExecFunc arrow_tsvector_delete_str() { return MakeIndirectExec<true, false>(&tsvector_delete_str); }
+TExecFunc arrow_tsvector_eq() { return MakeIndirectExec<true, true>(&tsvector_eq); }
+TExecFunc arrow_tsvector_filter() { return MakeIndirectExec<true, false>(&tsvector_filter); }
+TExecFunc arrow_tsvector_ge() { return MakeIndirectExec<true, true>(&tsvector_ge); }
+TExecFunc arrow_tsvector_gt() { return MakeIndirectExec<true, true>(&tsvector_gt); }
+TExecFunc arrow_tsvector_le() { return MakeIndirectExec<true, true>(&tsvector_le); }
+TExecFunc arrow_tsvector_length() { return MakeIndirectExec<true, true>(&tsvector_length); }
+TExecFunc arrow_tsvector_lt() { return MakeIndirectExec<true, true>(&tsvector_lt); }
+TExecFunc arrow_tsvector_ne() { return MakeIndirectExec<true, true>(&tsvector_ne); }
+TExecFunc arrow_tsvector_setweight() { return MakeIndirectExec<true, false>(&tsvector_setweight); }
+TExecFunc arrow_tsvector_setweight_by_filter() { return MakeIndirectExec<true, false>(&tsvector_setweight_by_filter); }
+TExecFunc arrow_tsvector_strip() { return MakeIndirectExec<true, false>(&tsvector_strip); }
+TExecFunc arrow_tsvector_to_array() { return MakeIndirectExec<true, false>(&tsvector_to_array); }
+TExecFunc arrow_tsvector_update_trigger_bycolumn() { return MakeIndirectExec<false, true>(&tsvector_update_trigger_bycolumn); }
+TExecFunc arrow_tsvector_update_trigger_byid() { return MakeIndirectExec<false, true>(&tsvector_update_trigger_byid); }
+TExecFunc arrow_unicode_is_normalized() { return MakeIndirectExec<true, true>(&unicode_is_normalized); }
+TExecFunc arrow_unicode_normalize_func() { return MakeIndirectExec<true, false>(&unicode_normalize_func); }
+TExecFunc arrow_unique_key_recheck() { return MakeIndirectExec<true, true>(&unique_key_recheck); }
+TExecFunc arrow_unistr() { return MakeIndirectExec<true, false>(&unistr); }
+TExecFunc arrow_unknownin() { return MakeIndirectExec<true, false>(&unknownin); }
+TExecFunc arrow_unknownout() { return MakeIndirectExec<true, false>(&unknownout); }
+TExecFunc arrow_unknownrecv() { return MakeIndirectExec<true, false>(&unknownrecv); }
+TExecFunc arrow_unknownsend() { return MakeIndirectExec<true, false>(&unknownsend); }
+TExecFunc arrow_websearch_to_tsquery() { return MakeIndirectExec<true, false>(&websearch_to_tsquery); }
+TExecFunc arrow_websearch_to_tsquery_byid() { return MakeIndirectExec<true, false>(&websearch_to_tsquery_byid); }
+TExecFunc arrow_width_bucket_array() { return MakeIndirectExec<true, true>(&width_bucket_array); }
+TExecFunc arrow_xml_in() { return MakeIndirectExec<true, false>(&xml_in); }
+TExecFunc arrow_xml_is_well_formed() { return MakeIndirectExec<true, true>(&xml_is_well_formed); }
+TExecFunc arrow_xml_is_well_formed_content() { return MakeIndirectExec<true, true>(&xml_is_well_formed_content); }
+TExecFunc arrow_xml_is_well_formed_document() { return MakeIndirectExec<true, true>(&xml_is_well_formed_document); }
+TExecFunc arrow_xml_out() { return MakeIndirectExec<true, false>(&xml_out); }
+TExecFunc arrow_xml_recv() { return MakeIndirectExec<true, false>(&xml_recv); }
+TExecFunc arrow_xml_send() { return MakeIndirectExec<true, false>(&xml_send); }
+TExecFunc arrow_xmlcomment() { return MakeIndirectExec<true, false>(&xmlcomment); }
+TExecFunc arrow_xmlconcat2() { return MakeIndirectExec<false, false>(&xmlconcat2); }
+TExecFunc arrow_xmlexists() { return MakeIndirectExec<true, true>(&xmlexists); }
+TExecFunc arrow_xmltotext() { return MakeIndirectExec<true, false>(&xmltotext); }
+TExecFunc arrow_xmlvalidate() { return MakeIndirectExec<true, true>(&xmlvalidate); }
+TExecFunc arrow_xpath() { return MakeIndirectExec<true, false>(&xpath); }
+TExecFunc arrow_xpath_exists() { return MakeIndirectExec<true, true>(&xpath_exists); }
diff --git a/ydb/library/yql/parser/pg_wrapper/pg_kernels.slow.2.inc b/ydb/library/yql/parser/pg_wrapper/pg_kernels.slow.2.inc
new file mode 100644
index 00000000000..a21611aaf05
--- /dev/null
+++ b/ydb/library/yql/parser/pg_wrapper/pg_kernels.slow.2.inc
@@ -0,0 +1,682 @@
+TExecFunc arrow_RI_FKey_cascade_del() { return MakeIndirectExec<true, true>(&RI_FKey_cascade_del); }
+TExecFunc arrow_RI_FKey_cascade_upd() { return MakeIndirectExec<true, true>(&RI_FKey_cascade_upd); }
+TExecFunc arrow_RI_FKey_check_ins() { return MakeIndirectExec<true, true>(&RI_FKey_check_ins); }
+TExecFunc arrow_RI_FKey_check_upd() { return MakeIndirectExec<true, true>(&RI_FKey_check_upd); }
+TExecFunc arrow_RI_FKey_noaction_del() { return MakeIndirectExec<true, true>(&RI_FKey_noaction_del); }
+TExecFunc arrow_RI_FKey_noaction_upd() { return MakeIndirectExec<true, true>(&RI_FKey_noaction_upd); }
+TExecFunc arrow_RI_FKey_restrict_del() { return MakeIndirectExec<true, true>(&RI_FKey_restrict_del); }
+TExecFunc arrow_RI_FKey_restrict_upd() { return MakeIndirectExec<true, true>(&RI_FKey_restrict_upd); }
+TExecFunc arrow_RI_FKey_setdefault_del() { return MakeIndirectExec<true, true>(&RI_FKey_setdefault_del); }
+TExecFunc arrow_RI_FKey_setdefault_upd() { return MakeIndirectExec<true, true>(&RI_FKey_setdefault_upd); }
+TExecFunc arrow_RI_FKey_setnull_del() { return MakeIndirectExec<true, true>(&RI_FKey_setnull_del); }
+TExecFunc arrow_RI_FKey_setnull_upd() { return MakeIndirectExec<true, true>(&RI_FKey_setnull_upd); }
+TExecFunc arrow_any_in() { return MakeIndirectExec<true, true>(&any_in); }
+TExecFunc arrow_any_out() { return MakeIndirectExec<true, false>(&any_out); }
+TExecFunc arrow_anyarray_in() { return MakeIndirectExec<true, false>(&anyarray_in); }
+TExecFunc arrow_anyarray_out() { return MakeIndirectExec<true, false>(&anyarray_out); }
+TExecFunc arrow_anyarray_recv() { return MakeIndirectExec<true, false>(&anyarray_recv); }
+TExecFunc arrow_anyarray_send() { return MakeIndirectExec<true, false>(&anyarray_send); }
+TExecFunc arrow_anycompatible_in() { return MakeIndirectExec<true, true>(&anycompatible_in); }
+TExecFunc arrow_anycompatible_out() { return MakeIndirectExec<true, false>(&anycompatible_out); }
+TExecFunc arrow_anycompatiblearray_in() { return MakeIndirectExec<true, false>(&anycompatiblearray_in); }
+TExecFunc arrow_anycompatiblearray_out() { return MakeIndirectExec<true, false>(&anycompatiblearray_out); }
+TExecFunc arrow_anycompatiblearray_recv() { return MakeIndirectExec<true, false>(&anycompatiblearray_recv); }
+TExecFunc arrow_anycompatiblearray_send() { return MakeIndirectExec<true, false>(&anycompatiblearray_send); }
+TExecFunc arrow_anycompatiblemultirange_in() { return MakeIndirectExec<true, false>(&anycompatiblemultirange_in); }
+TExecFunc arrow_anycompatiblemultirange_out() { return MakeIndirectExec<true, false>(&anycompatiblemultirange_out); }
+TExecFunc arrow_anycompatiblenonarray_in() { return MakeIndirectExec<true, true>(&anycompatiblenonarray_in); }
+TExecFunc arrow_anycompatiblenonarray_out() { return MakeIndirectExec<true, false>(&anycompatiblenonarray_out); }
+TExecFunc arrow_anycompatiblerange_in() { return MakeIndirectExec<true, false>(&anycompatiblerange_in); }
+TExecFunc arrow_anycompatiblerange_out() { return MakeIndirectExec<true, false>(&anycompatiblerange_out); }
+TExecFunc arrow_anyelement_in() { return MakeIndirectExec<true, true>(&anyelement_in); }
+TExecFunc arrow_anyelement_out() { return MakeIndirectExec<true, false>(&anyelement_out); }
+TExecFunc arrow_anyenum_in() { return MakeIndirectExec<true, true>(&anyenum_in); }
+TExecFunc arrow_anyenum_out() { return MakeIndirectExec<true, false>(&anyenum_out); }
+TExecFunc arrow_anymultirange_in() { return MakeIndirectExec<true, false>(&anymultirange_in); }
+TExecFunc arrow_anymultirange_out() { return MakeIndirectExec<true, false>(&anymultirange_out); }
+TExecFunc arrow_anynonarray_in() { return MakeIndirectExec<true, true>(&anynonarray_in); }
+TExecFunc arrow_anynonarray_out() { return MakeIndirectExec<true, false>(&anynonarray_out); }
+TExecFunc arrow_anyrange_in() { return MakeIndirectExec<true, false>(&anyrange_in); }
+TExecFunc arrow_anyrange_out() { return MakeIndirectExec<true, false>(&anyrange_out); }
+TExecFunc arrow_arraycontjoinsel() { return MakeIndirectExec<true, true>(&arraycontjoinsel); }
+TExecFunc arrow_arraycontsel() { return MakeIndirectExec<true, true>(&arraycontsel); }
+TExecFunc arrow_bpchar() { return MakeIndirectExec<true, false>(&bpchar); }
+TExecFunc arrow_bpchar_larger() { return MakeIndirectExec<true, false>(&bpchar_larger); }
+TExecFunc arrow_bpchar_name() { return MakeIndirectExec<true, false>(&bpchar_name); }
+TExecFunc arrow_bpchar_pattern_ge() { return MakeIndirectExec<true, true>(&bpchar_pattern_ge); }
+TExecFunc arrow_bpchar_pattern_gt() { return MakeIndirectExec<true, true>(&bpchar_pattern_gt); }
+TExecFunc arrow_bpchar_pattern_le() { return MakeIndirectExec<true, true>(&bpchar_pattern_le); }
+TExecFunc arrow_bpchar_pattern_lt() { return MakeIndirectExec<true, true>(&bpchar_pattern_lt); }
+TExecFunc arrow_bpchar_smaller() { return MakeIndirectExec<true, false>(&bpchar_smaller); }
+TExecFunc arrow_bpchar_sortsupport() { return MakeIndirectExec<true, true>(&bpchar_sortsupport); }
+TExecFunc arrow_bpcharcmp() { return MakeIndirectExec<true, true>(&bpcharcmp); }
+TExecFunc arrow_bpchareq() { return MakeIndirectExec<true, true>(&bpchareq); }
+TExecFunc arrow_bpcharge() { return MakeIndirectExec<true, true>(&bpcharge); }
+TExecFunc arrow_bpchargt() { return MakeIndirectExec<true, true>(&bpchargt); }
+TExecFunc arrow_bpcharin() { return MakeIndirectExec<true, false>(&bpcharin); }
+TExecFunc arrow_bpcharle() { return MakeIndirectExec<true, true>(&bpcharle); }
+TExecFunc arrow_bpcharlen() { return MakeIndirectExec<true, true>(&bpcharlen); }
+TExecFunc arrow_bpcharlt() { return MakeIndirectExec<true, true>(&bpcharlt); }
+TExecFunc arrow_bpcharne() { return MakeIndirectExec<true, true>(&bpcharne); }
+TExecFunc arrow_bpcharoctetlen() { return MakeIndirectExec<true, true>(&bpcharoctetlen); }
+TExecFunc arrow_bpcharout() { return MakeIndirectExec<true, false>(&bpcharout); }
+TExecFunc arrow_bpcharrecv() { return MakeIndirectExec<true, false>(&bpcharrecv); }
+TExecFunc arrow_bpcharsend() { return MakeIndirectExec<true, false>(&bpcharsend); }
+TExecFunc arrow_bpchartypmodin() { return MakeIndirectExec<true, true>(&bpchartypmodin); }
+TExecFunc arrow_bpchartypmodout() { return MakeIndirectExec<true, false>(&bpchartypmodout); }
+TExecFunc arrow_brin_minmax_add_value() { return MakeIndirectExec<true, true>(&brin_minmax_add_value); }
+TExecFunc arrow_brin_minmax_consistent() { return MakeIndirectExec<true, true>(&brin_minmax_consistent); }
+TExecFunc arrow_brin_minmax_opcinfo() { return MakeIndirectExec<true, true>(&brin_minmax_opcinfo); }
+TExecFunc arrow_brin_minmax_union() { return MakeIndirectExec<true, true>(&brin_minmax_union); }
+TExecFunc arrow_btbpchar_pattern_cmp() { return MakeIndirectExec<true, true>(&btbpchar_pattern_cmp); }
+TExecFunc arrow_btbpchar_pattern_sortsupport() { return MakeIndirectExec<true, true>(&btbpchar_pattern_sortsupport); }
+TExecFunc arrow_btfloat48cmp() { return MakeIndirectExec<true, true>(&btfloat48cmp); }
+TExecFunc arrow_btfloat4cmp() { return MakeIndirectExec<true, true>(&btfloat4cmp); }
+TExecFunc arrow_btfloat4sortsupport() { return MakeIndirectExec<true, true>(&btfloat4sortsupport); }
+TExecFunc arrow_btfloat84cmp() { return MakeIndirectExec<true, true>(&btfloat84cmp); }
+TExecFunc arrow_btfloat8cmp() { return MakeIndirectExec<true, true>(&btfloat8cmp); }
+TExecFunc arrow_btfloat8sortsupport() { return MakeIndirectExec<true, true>(&btfloat8sortsupport); }
+TExecFunc arrow_btnamecmp() { return MakeIndirectExec<true, true>(&btnamecmp); }
+TExecFunc arrow_btnamesortsupport() { return MakeIndirectExec<true, true>(&btnamesortsupport); }
+TExecFunc arrow_btrecordcmp() { return MakeIndirectExec<true, true>(&btrecordcmp); }
+TExecFunc arrow_btrecordimagecmp() { return MakeIndirectExec<true, true>(&btrecordimagecmp); }
+TExecFunc arrow_char_bpchar() { return MakeIndirectExec<true, false>(&char_bpchar); }
+TExecFunc arrow_cideq() { return MakeIndirectExec<true, true>(&cideq); }
+TExecFunc arrow_cidin() { return MakeIndirectExec<true, true>(&cidin); }
+TExecFunc arrow_cidout() { return MakeIndirectExec<true, false>(&cidout); }
+TExecFunc arrow_cidrecv() { return MakeIndirectExec<true, true>(&cidrecv); }
+TExecFunc arrow_cidsend() { return MakeIndirectExec<true, false>(&cidsend); }
+TExecFunc arrow_cstring_in() { return MakeIndirectExec<true, false>(&cstring_in); }
+TExecFunc arrow_cstring_out() { return MakeIndirectExec<true, false>(&cstring_out); }
+TExecFunc arrow_cstring_recv() { return MakeIndirectExec<true, false>(&cstring_recv); }
+TExecFunc arrow_cstring_send() { return MakeIndirectExec<true, false>(&cstring_send); }
+TExecFunc arrow_current_schema() { return MakeIndirectExec<true, false>(&current_schema); }
+TExecFunc arrow_current_schemas() { return MakeIndirectExec<true, false>(&current_schemas); }
+TExecFunc arrow_current_user() { return MakeIndirectExec<true, false>(&current_user); }
+TExecFunc arrow_currval_oid() { return MakeIndirectExec<true, true>(&currval_oid); }
+TExecFunc arrow_dacos() { return MakeIndirectExec<true, true>(&dacos); }
+TExecFunc arrow_dacosd() { return MakeIndirectExec<true, true>(&dacosd); }
+TExecFunc arrow_dacosh() { return MakeIndirectExec<true, true>(&dacosh); }
+TExecFunc arrow_dasin() { return MakeIndirectExec<true, true>(&dasin); }
+TExecFunc arrow_dasind() { return MakeIndirectExec<true, true>(&dasind); }
+TExecFunc arrow_dasinh() { return MakeIndirectExec<true, true>(&dasinh); }
+TExecFunc arrow_datan() { return MakeIndirectExec<true, true>(&datan); }
+TExecFunc arrow_datan2() { return MakeIndirectExec<true, true>(&datan2); }
+TExecFunc arrow_datan2d() { return MakeIndirectExec<true, true>(&datan2d); }
+TExecFunc arrow_datand() { return MakeIndirectExec<true, true>(&datand); }
+TExecFunc arrow_datanh() { return MakeIndirectExec<true, true>(&datanh); }
+TExecFunc arrow_dcbrt() { return MakeIndirectExec<true, true>(&dcbrt); }
+TExecFunc arrow_dceil() { return MakeIndirectExec<true, true>(&dceil); }
+TExecFunc arrow_dcos() { return MakeIndirectExec<true, true>(&dcos); }
+TExecFunc arrow_dcosd() { return MakeIndirectExec<true, true>(&dcosd); }
+TExecFunc arrow_dcosh() { return MakeIndirectExec<true, true>(&dcosh); }
+TExecFunc arrow_dcot() { return MakeIndirectExec<true, true>(&dcot); }
+TExecFunc arrow_dcotd() { return MakeIndirectExec<true, true>(&dcotd); }
+TExecFunc arrow_degrees() { return MakeIndirectExec<true, true>(&degrees); }
+TExecFunc arrow_dexp() { return MakeIndirectExec<true, true>(&dexp); }
+TExecFunc arrow_dfloor() { return MakeIndirectExec<true, true>(&dfloor); }
+TExecFunc arrow_dispell_init() { return MakeIndirectExec<true, true>(&dispell_init); }
+TExecFunc arrow_dispell_lexize() { return MakeIndirectExec<true, true>(&dispell_lexize); }
+TExecFunc arrow_dlog1() { return MakeIndirectExec<true, true>(&dlog1); }
+TExecFunc arrow_dlog10() { return MakeIndirectExec<true, true>(&dlog10); }
+TExecFunc arrow_domain_in() { return MakeIndirectExec<false, true>(&domain_in); }
+TExecFunc arrow_domain_recv() { return MakeIndirectExec<false, true>(&domain_recv); }
+TExecFunc arrow_dpi() { return MakeIndirectExec<true, true>(&dpi); }
+TExecFunc arrow_dpow() { return MakeIndirectExec<true, true>(&dpow); }
+TExecFunc arrow_drandom() { return MakeIndirectExec<true, true>(&drandom); }
+TExecFunc arrow_dround() { return MakeIndirectExec<true, true>(&dround); }
+TExecFunc arrow_dsign() { return MakeIndirectExec<true, true>(&dsign); }
+TExecFunc arrow_dsin() { return MakeIndirectExec<true, true>(&dsin); }
+TExecFunc arrow_dsind() { return MakeIndirectExec<true, true>(&dsind); }
+TExecFunc arrow_dsinh() { return MakeIndirectExec<true, true>(&dsinh); }
+TExecFunc arrow_dsqrt() { return MakeIndirectExec<true, true>(&dsqrt); }
+TExecFunc arrow_dsynonym_init() { return MakeIndirectExec<true, true>(&dsynonym_init); }
+TExecFunc arrow_dsynonym_lexize() { return MakeIndirectExec<true, true>(&dsynonym_lexize); }
+TExecFunc arrow_dtan() { return MakeIndirectExec<true, true>(&dtan); }
+TExecFunc arrow_dtand() { return MakeIndirectExec<true, true>(&dtand); }
+TExecFunc arrow_dtanh() { return MakeIndirectExec<true, true>(&dtanh); }
+TExecFunc arrow_dtof() { return MakeIndirectExec<true, true>(&dtof); }
+TExecFunc arrow_dtoi2() { return MakeIndirectExec<true, true>(&dtoi2); }
+TExecFunc arrow_dtoi4() { return MakeIndirectExec<true, true>(&dtoi4); }
+TExecFunc arrow_dtrunc() { return MakeIndirectExec<true, true>(&dtrunc); }
+TExecFunc arrow_elem_contained_by_multirange() { return MakeIndirectExec<true, true>(&elem_contained_by_multirange); }
+TExecFunc arrow_event_trigger_in() { return MakeIndirectExec<false, true>(&event_trigger_in); }
+TExecFunc arrow_event_trigger_out() { return MakeIndirectExec<true, false>(&event_trigger_out); }
+TExecFunc arrow_fdw_handler_in() { return MakeIndirectExec<false, true>(&fdw_handler_in); }
+TExecFunc arrow_fdw_handler_out() { return MakeIndirectExec<true, false>(&fdw_handler_out); }
+TExecFunc arrow_float48div() { return MakeIndirectExec<true, true>(&float48div); }
+TExecFunc arrow_float48eq() { return MakeIndirectExec<true, true>(&float48eq); }
+TExecFunc arrow_float48ge() { return MakeIndirectExec<true, true>(&float48ge); }
+TExecFunc arrow_float48gt() { return MakeIndirectExec<true, true>(&float48gt); }
+TExecFunc arrow_float48le() { return MakeIndirectExec<true, true>(&float48le); }
+TExecFunc arrow_float48lt() { return MakeIndirectExec<true, true>(&float48lt); }
+TExecFunc arrow_float48mi() { return MakeIndirectExec<true, true>(&float48mi); }
+TExecFunc arrow_float48mul() { return MakeIndirectExec<true, true>(&float48mul); }
+TExecFunc arrow_float48ne() { return MakeIndirectExec<true, true>(&float48ne); }
+TExecFunc arrow_float48pl() { return MakeIndirectExec<true, true>(&float48pl); }
+TExecFunc arrow_float4_accum() { return MakeIndirectExec<true, false>(&float4_accum); }
+TExecFunc arrow_float4abs() { return MakeIndirectExec<true, true>(&float4abs); }
+TExecFunc arrow_float4div() { return MakeIndirectExec<true, true>(&float4div); }
+TExecFunc arrow_float4eq() { return MakeIndirectExec<true, true>(&float4eq); }
+TExecFunc arrow_float4ge() { return MakeIndirectExec<true, true>(&float4ge); }
+TExecFunc arrow_float4gt() { return MakeIndirectExec<true, true>(&float4gt); }
+TExecFunc arrow_float4in() { return MakeIndirectExec<true, true>(&float4in); }
+TExecFunc arrow_float4larger() { return MakeIndirectExec<true, true>(&float4larger); }
+TExecFunc arrow_float4le() { return MakeIndirectExec<true, true>(&float4le); }
+TExecFunc arrow_float4lt() { return MakeIndirectExec<true, true>(&float4lt); }
+TExecFunc arrow_float4mi() { return MakeIndirectExec<true, true>(&float4mi); }
+TExecFunc arrow_float4mul() { return MakeIndirectExec<true, true>(&float4mul); }
+TExecFunc arrow_float4ne() { return MakeIndirectExec<true, true>(&float4ne); }
+TExecFunc arrow_float4out() { return MakeIndirectExec<true, false>(&float4out); }
+TExecFunc arrow_float4pl() { return MakeIndirectExec<true, true>(&float4pl); }
+TExecFunc arrow_float4recv() { return MakeIndirectExec<true, true>(&float4recv); }
+TExecFunc arrow_float4send() { return MakeIndirectExec<true, false>(&float4send); }
+TExecFunc arrow_float4smaller() { return MakeIndirectExec<true, true>(&float4smaller); }
+TExecFunc arrow_float4um() { return MakeIndirectExec<true, true>(&float4um); }
+TExecFunc arrow_float4up() { return MakeIndirectExec<true, true>(&float4up); }
+TExecFunc arrow_float84div() { return MakeIndirectExec<true, true>(&float84div); }
+TExecFunc arrow_float84eq() { return MakeIndirectExec<true, true>(&float84eq); }
+TExecFunc arrow_float84ge() { return MakeIndirectExec<true, true>(&float84ge); }
+TExecFunc arrow_float84gt() { return MakeIndirectExec<true, true>(&float84gt); }
+TExecFunc arrow_float84le() { return MakeIndirectExec<true, true>(&float84le); }
+TExecFunc arrow_float84lt() { return MakeIndirectExec<true, true>(&float84lt); }
+TExecFunc arrow_float84mi() { return MakeIndirectExec<true, true>(&float84mi); }
+TExecFunc arrow_float84mul() { return MakeIndirectExec<true, true>(&float84mul); }
+TExecFunc arrow_float84ne() { return MakeIndirectExec<true, true>(&float84ne); }
+TExecFunc arrow_float84pl() { return MakeIndirectExec<true, true>(&float84pl); }
+TExecFunc arrow_float8_accum() { return MakeIndirectExec<true, false>(&float8_accum); }
+TExecFunc arrow_float8_avg() { return MakeIndirectExec<true, true>(&float8_avg); }
+TExecFunc arrow_float8_combine() { return MakeIndirectExec<true, false>(&float8_combine); }
+TExecFunc arrow_float8_corr() { return MakeIndirectExec<true, true>(&float8_corr); }
+TExecFunc arrow_float8_covar_pop() { return MakeIndirectExec<true, true>(&float8_covar_pop); }
+TExecFunc arrow_float8_covar_samp() { return MakeIndirectExec<true, true>(&float8_covar_samp); }
+TExecFunc arrow_float8_regr_accum() { return MakeIndirectExec<true, false>(&float8_regr_accum); }
+TExecFunc arrow_float8_regr_avgx() { return MakeIndirectExec<true, true>(&float8_regr_avgx); }
+TExecFunc arrow_float8_regr_avgy() { return MakeIndirectExec<true, true>(&float8_regr_avgy); }
+TExecFunc arrow_float8_regr_combine() { return MakeIndirectExec<true, false>(&float8_regr_combine); }
+TExecFunc arrow_float8_regr_intercept() { return MakeIndirectExec<true, true>(&float8_regr_intercept); }
+TExecFunc arrow_float8_regr_r2() { return MakeIndirectExec<true, true>(&float8_regr_r2); }
+TExecFunc arrow_float8_regr_slope() { return MakeIndirectExec<true, true>(&float8_regr_slope); }
+TExecFunc arrow_float8_regr_sxx() { return MakeIndirectExec<true, true>(&float8_regr_sxx); }
+TExecFunc arrow_float8_regr_sxy() { return MakeIndirectExec<true, true>(&float8_regr_sxy); }
+TExecFunc arrow_float8_regr_syy() { return MakeIndirectExec<true, true>(&float8_regr_syy); }
+TExecFunc arrow_float8_stddev_pop() { return MakeIndirectExec<true, true>(&float8_stddev_pop); }
+TExecFunc arrow_float8_stddev_samp() { return MakeIndirectExec<true, true>(&float8_stddev_samp); }
+TExecFunc arrow_float8_var_pop() { return MakeIndirectExec<true, true>(&float8_var_pop); }
+TExecFunc arrow_float8_var_samp() { return MakeIndirectExec<true, true>(&float8_var_samp); }
+TExecFunc arrow_float8abs() { return MakeIndirectExec<true, true>(&float8abs); }
+TExecFunc arrow_float8div() { return MakeIndirectExec<true, true>(&float8div); }
+TExecFunc arrow_float8eq() { return MakeIndirectExec<true, true>(&float8eq); }
+TExecFunc arrow_float8ge() { return MakeIndirectExec<true, true>(&float8ge); }
+TExecFunc arrow_float8gt() { return MakeIndirectExec<true, true>(&float8gt); }
+TExecFunc arrow_float8in() { return MakeIndirectExec<true, true>(&float8in); }
+TExecFunc arrow_float8larger() { return MakeIndirectExec<true, true>(&float8larger); }
+TExecFunc arrow_float8le() { return MakeIndirectExec<true, true>(&float8le); }
+TExecFunc arrow_float8lt() { return MakeIndirectExec<true, true>(&float8lt); }
+TExecFunc arrow_float8mi() { return MakeIndirectExec<true, true>(&float8mi); }
+TExecFunc arrow_float8mul() { return MakeIndirectExec<true, true>(&float8mul); }
+TExecFunc arrow_float8ne() { return MakeIndirectExec<true, true>(&float8ne); }
+TExecFunc arrow_float8out() { return MakeIndirectExec<true, false>(&float8out); }
+TExecFunc arrow_float8pl() { return MakeIndirectExec<true, true>(&float8pl); }
+TExecFunc arrow_float8recv() { return MakeIndirectExec<true, true>(&float8recv); }
+TExecFunc arrow_float8send() { return MakeIndirectExec<true, false>(&float8send); }
+TExecFunc arrow_float8smaller() { return MakeIndirectExec<true, true>(&float8smaller); }
+TExecFunc arrow_float8um() { return MakeIndirectExec<true, true>(&float8um); }
+TExecFunc arrow_float8up() { return MakeIndirectExec<true, true>(&float8up); }
+TExecFunc arrow_ftod() { return MakeIndirectExec<true, true>(&ftod); }
+TExecFunc arrow_ftoi2() { return MakeIndirectExec<true, true>(&ftoi2); }
+TExecFunc arrow_ftoi4() { return MakeIndirectExec<true, true>(&ftoi4); }
+TExecFunc arrow_gin_clean_pending_list() { return MakeIndirectExec<true, true>(&gin_clean_pending_list); }
+TExecFunc arrow_ginhandler() { return MakeIndirectExec<true, true>(&ginhandler); }
+TExecFunc arrow_gist_box_consistent() { return MakeIndirectExec<true, true>(&gist_box_consistent); }
+TExecFunc arrow_gist_box_distance() { return MakeIndirectExec<true, true>(&gist_box_distance); }
+TExecFunc arrow_gist_box_penalty() { return MakeIndirectExec<true, true>(&gist_box_penalty); }
+TExecFunc arrow_gist_box_picksplit() { return MakeIndirectExec<true, true>(&gist_box_picksplit); }
+TExecFunc arrow_gist_box_same() { return MakeIndirectExec<true, true>(&gist_box_same); }
+TExecFunc arrow_gist_box_union() { return MakeIndirectExec<true, false>(&gist_box_union); }
+TExecFunc arrow_gist_circle_compress() { return MakeIndirectExec<true, true>(&gist_circle_compress); }
+TExecFunc arrow_gist_circle_consistent() { return MakeIndirectExec<true, true>(&gist_circle_consistent); }
+TExecFunc arrow_gist_circle_distance() { return MakeIndirectExec<true, true>(&gist_circle_distance); }
+TExecFunc arrow_gist_point_compress() { return MakeIndirectExec<true, true>(&gist_point_compress); }
+TExecFunc arrow_gist_point_consistent() { return MakeIndirectExec<true, true>(&gist_point_consistent); }
+TExecFunc arrow_gist_point_distance() { return MakeIndirectExec<true, true>(&gist_point_distance); }
+TExecFunc arrow_gist_point_fetch() { return MakeIndirectExec<true, true>(&gist_point_fetch); }
+TExecFunc arrow_gist_point_sortsupport() { return MakeIndirectExec<true, true>(&gist_point_sortsupport); }
+TExecFunc arrow_gist_poly_compress() { return MakeIndirectExec<true, true>(&gist_poly_compress); }
+TExecFunc arrow_gist_poly_consistent() { return MakeIndirectExec<true, true>(&gist_poly_consistent); }
+TExecFunc arrow_gist_poly_distance() { return MakeIndirectExec<true, true>(&gist_poly_distance); }
+TExecFunc arrow_hash_multirange() { return MakeIndirectExec<true, true>(&hash_multirange); }
+TExecFunc arrow_hash_multirange_extended() { return MakeIndirectExec<true, true>(&hash_multirange_extended); }
+TExecFunc arrow_hash_record() { return MakeIndirectExec<true, true>(&hash_record); }
+TExecFunc arrow_hash_record_extended() { return MakeIndirectExec<true, true>(&hash_record_extended); }
+TExecFunc arrow_hashbpchar() { return MakeIndirectExec<true, true>(&hashbpchar); }
+TExecFunc arrow_hashbpcharextended() { return MakeIndirectExec<true, true>(&hashbpcharextended); }
+TExecFunc arrow_hashhandler() { return MakeIndirectExec<true, true>(&hashhandler); }
+TExecFunc arrow_hashmacaddr() { return MakeIndirectExec<true, true>(&hashmacaddr); }
+TExecFunc arrow_hashmacaddrextended() { return MakeIndirectExec<true, true>(&hashmacaddrextended); }
+TExecFunc arrow_i2tod() { return MakeIndirectExec<true, true>(&i2tod); }
+TExecFunc arrow_i2tof() { return MakeIndirectExec<true, true>(&i2tof); }
+TExecFunc arrow_i4tod() { return MakeIndirectExec<true, true>(&i4tod); }
+TExecFunc arrow_i4tof() { return MakeIndirectExec<true, true>(&i4tof); }
+TExecFunc arrow_in_range_float4_float8() { return MakeIndirectExec<true, true>(&in_range_float4_float8); }
+TExecFunc arrow_in_range_float8_float8() { return MakeIndirectExec<true, true>(&in_range_float8_float8); }
+TExecFunc arrow_index_am_handler_in() { return MakeIndirectExec<false, true>(&index_am_handler_in); }
+TExecFunc arrow_index_am_handler_out() { return MakeIndirectExec<true, false>(&index_am_handler_out); }
+TExecFunc arrow_internal_in() { return MakeIndirectExec<false, true>(&internal_in); }
+TExecFunc arrow_internal_out() { return MakeIndirectExec<true, false>(&internal_out); }
+TExecFunc arrow_language_handler_in() { return MakeIndirectExec<false, true>(&language_handler_in); }
+TExecFunc arrow_language_handler_out() { return MakeIndirectExec<true, false>(&language_handler_out); }
+TExecFunc arrow_lastval() { return MakeIndirectExec<true, true>(&lastval); }
+TExecFunc arrow_macaddr_and() { return MakeIndirectExec<true, false>(&macaddr_and); }
+TExecFunc arrow_macaddr_cmp() { return MakeIndirectExec<true, true>(&macaddr_cmp); }
+TExecFunc arrow_macaddr_eq() { return MakeIndirectExec<true, true>(&macaddr_eq); }
+TExecFunc arrow_macaddr_ge() { return MakeIndirectExec<true, true>(&macaddr_ge); }
+TExecFunc arrow_macaddr_gt() { return MakeIndirectExec<true, true>(&macaddr_gt); }
+TExecFunc arrow_macaddr_in() { return MakeIndirectExec<true, false>(&macaddr_in); }
+TExecFunc arrow_macaddr_le() { return MakeIndirectExec<true, true>(&macaddr_le); }
+TExecFunc arrow_macaddr_lt() { return MakeIndirectExec<true, true>(&macaddr_lt); }
+TExecFunc arrow_macaddr_ne() { return MakeIndirectExec<true, true>(&macaddr_ne); }
+TExecFunc arrow_macaddr_not() { return MakeIndirectExec<true, false>(&macaddr_not); }
+TExecFunc arrow_macaddr_or() { return MakeIndirectExec<true, false>(&macaddr_or); }
+TExecFunc arrow_macaddr_out() { return MakeIndirectExec<true, false>(&macaddr_out); }
+TExecFunc arrow_macaddr_recv() { return MakeIndirectExec<true, false>(&macaddr_recv); }
+TExecFunc arrow_macaddr_send() { return MakeIndirectExec<true, false>(&macaddr_send); }
+TExecFunc arrow_macaddr_sortsupport() { return MakeIndirectExec<true, true>(&macaddr_sortsupport); }
+TExecFunc arrow_macaddr_trunc() { return MakeIndirectExec<true, false>(&macaddr_trunc); }
+TExecFunc arrow_mode_final() { return MakeIndirectExec<false, true>(&mode_final); }
+TExecFunc arrow_multirange_adjacent_multirange() { return MakeIndirectExec<true, true>(&multirange_adjacent_multirange); }
+TExecFunc arrow_multirange_adjacent_range() { return MakeIndirectExec<true, true>(&multirange_adjacent_range); }
+TExecFunc arrow_multirange_after_multirange() { return MakeIndirectExec<true, true>(&multirange_after_multirange); }
+TExecFunc arrow_multirange_after_range() { return MakeIndirectExec<true, true>(&multirange_after_range); }
+TExecFunc arrow_multirange_before_multirange() { return MakeIndirectExec<true, true>(&multirange_before_multirange); }
+TExecFunc arrow_multirange_before_range() { return MakeIndirectExec<true, true>(&multirange_before_range); }
+TExecFunc arrow_multirange_cmp() { return MakeIndirectExec<true, true>(&multirange_cmp); }
+TExecFunc arrow_multirange_constructor0() { return MakeIndirectExec<true, false>(&multirange_constructor0); }
+TExecFunc arrow_multirange_constructor1() { return MakeIndirectExec<true, false>(&multirange_constructor1); }
+TExecFunc arrow_multirange_contained_by_multirange() { return MakeIndirectExec<true, true>(&multirange_contained_by_multirange); }
+TExecFunc arrow_multirange_contained_by_range() { return MakeIndirectExec<true, true>(&multirange_contained_by_range); }
+TExecFunc arrow_multirange_contains_elem() { return MakeIndirectExec<true, true>(&multirange_contains_elem); }
+TExecFunc arrow_multirange_contains_multirange() { return MakeIndirectExec<true, true>(&multirange_contains_multirange); }
+TExecFunc arrow_multirange_contains_range() { return MakeIndirectExec<true, true>(&multirange_contains_range); }
+TExecFunc arrow_multirange_empty() { return MakeIndirectExec<true, true>(&multirange_empty); }
+TExecFunc arrow_multirange_eq() { return MakeIndirectExec<true, true>(&multirange_eq); }
+TExecFunc arrow_multirange_ge() { return MakeIndirectExec<true, true>(&multirange_ge); }
+TExecFunc arrow_multirange_gt() { return MakeIndirectExec<true, true>(&multirange_gt); }
+TExecFunc arrow_multirange_in() { return MakeIndirectExec<true, false>(&multirange_in); }
+TExecFunc arrow_multirange_intersect() { return MakeIndirectExec<true, false>(&multirange_intersect); }
+TExecFunc arrow_multirange_intersect_agg_transfn() { return MakeIndirectExec<true, false>(&multirange_intersect_agg_transfn); }
+TExecFunc arrow_multirange_le() { return MakeIndirectExec<true, true>(&multirange_le); }
+TExecFunc arrow_multirange_lower() { return MakeIndirectExec<true, true>(&multirange_lower); }
+TExecFunc arrow_multirange_lower_inc() { return MakeIndirectExec<true, true>(&multirange_lower_inc); }
+TExecFunc arrow_multirange_lower_inf() { return MakeIndirectExec<true, true>(&multirange_lower_inf); }
+TExecFunc arrow_multirange_lt() { return MakeIndirectExec<true, true>(&multirange_lt); }
+TExecFunc arrow_multirange_minus() { return MakeIndirectExec<true, false>(&multirange_minus); }
+TExecFunc arrow_multirange_ne() { return MakeIndirectExec<true, true>(&multirange_ne); }
+TExecFunc arrow_multirange_out() { return MakeIndirectExec<true, false>(&multirange_out); }
+TExecFunc arrow_multirange_overlaps_multirange() { return MakeIndirectExec<true, true>(&multirange_overlaps_multirange); }
+TExecFunc arrow_multirange_overlaps_range() { return MakeIndirectExec<true, true>(&multirange_overlaps_range); }
+TExecFunc arrow_multirange_overleft_multirange() { return MakeIndirectExec<true, true>(&multirange_overleft_multirange); }
+TExecFunc arrow_multirange_overleft_range() { return MakeIndirectExec<true, true>(&multirange_overleft_range); }
+TExecFunc arrow_multirange_overright_multirange() { return MakeIndirectExec<true, true>(&multirange_overright_multirange); }
+TExecFunc arrow_multirange_overright_range() { return MakeIndirectExec<true, true>(&multirange_overright_range); }
+TExecFunc arrow_multirange_recv() { return MakeIndirectExec<true, false>(&multirange_recv); }
+TExecFunc arrow_multirange_send() { return MakeIndirectExec<true, false>(&multirange_send); }
+TExecFunc arrow_multirange_union() { return MakeIndirectExec<true, false>(&multirange_union); }
+TExecFunc arrow_multirange_upper() { return MakeIndirectExec<true, true>(&multirange_upper); }
+TExecFunc arrow_multirange_upper_inc() { return MakeIndirectExec<true, true>(&multirange_upper_inc); }
+TExecFunc arrow_multirange_upper_inf() { return MakeIndirectExec<true, true>(&multirange_upper_inf); }
+TExecFunc arrow_multirangesel() { return MakeIndirectExec<true, true>(&multirangesel); }
+TExecFunc arrow_mxid_age() { return MakeIndirectExec<true, true>(&mxid_age); }
+TExecFunc arrow_name_bpchar() { return MakeIndirectExec<true, false>(&name_bpchar); }
+TExecFunc arrow_nameconcatoid() { return MakeIndirectExec<true, false>(&nameconcatoid); }
+TExecFunc arrow_nameeq() { return MakeIndirectExec<true, true>(&nameeq); }
+TExecFunc arrow_namege() { return MakeIndirectExec<true, true>(&namege); }
+TExecFunc arrow_namegt() { return MakeIndirectExec<true, true>(&namegt); }
+TExecFunc arrow_namein() { return MakeIndirectExec<true, false>(&namein); }
+TExecFunc arrow_namele() { return MakeIndirectExec<true, true>(&namele); }
+TExecFunc arrow_namelt() { return MakeIndirectExec<true, true>(&namelt); }
+TExecFunc arrow_namene() { return MakeIndirectExec<true, true>(&namene); }
+TExecFunc arrow_nameout() { return MakeIndirectExec<true, false>(&nameout); }
+TExecFunc arrow_namerecv() { return MakeIndirectExec<true, false>(&namerecv); }
+TExecFunc arrow_namesend() { return MakeIndirectExec<true, false>(&namesend); }
+TExecFunc arrow_networkjoinsel() { return MakeIndirectExec<true, true>(&networkjoinsel); }
+TExecFunc arrow_networksel() { return MakeIndirectExec<true, true>(&networksel); }
+TExecFunc arrow_nextval_oid() { return MakeIndirectExec<true, true>(&nextval_oid); }
+TExecFunc arrow_ordered_set_transition() { return MakeIndirectExec<false, true>(&ordered_set_transition); }
+TExecFunc arrow_percentile_cont_float8_final() { return MakeIndirectExec<false, true>(&percentile_cont_float8_final); }
+TExecFunc arrow_percentile_cont_float8_multi_final() { return MakeIndirectExec<false, false>(&percentile_cont_float8_multi_final); }
+TExecFunc arrow_percentile_cont_interval_final() { return MakeIndirectExec<false, false>(&percentile_cont_interval_final); }
+TExecFunc arrow_percentile_cont_interval_multi_final() { return MakeIndirectExec<false, false>(&percentile_cont_interval_multi_final); }
+TExecFunc arrow_percentile_disc_final() { return MakeIndirectExec<false, true>(&percentile_disc_final); }
+TExecFunc arrow_percentile_disc_multi_final() { return MakeIndirectExec<false, false>(&percentile_disc_multi_final); }
+TExecFunc arrow_pg_backend_pid() { return MakeIndirectExec<true, true>(&pg_backend_pid); }
+TExecFunc arrow_pg_backup_start_time() { return MakeIndirectExec<true, true>(&pg_backup_start_time); }
+TExecFunc arrow_pg_collation_is_visible() { return MakeIndirectExec<true, true>(&pg_collation_is_visible); }
+TExecFunc arrow_pg_control_checkpoint() { return MakeIndirectExec<true, false>(&pg_control_checkpoint); }
+TExecFunc arrow_pg_control_init() { return MakeIndirectExec<true, false>(&pg_control_init); }
+TExecFunc arrow_pg_control_recovery() { return MakeIndirectExec<true, false>(&pg_control_recovery); }
+TExecFunc arrow_pg_control_system() { return MakeIndirectExec<true, false>(&pg_control_system); }
+TExecFunc arrow_pg_conversion_is_visible() { return MakeIndirectExec<true, true>(&pg_conversion_is_visible); }
+TExecFunc arrow_pg_create_restore_point() { return MakeIndirectExec<true, true>(&pg_create_restore_point); }
+TExecFunc arrow_pg_current_wal_flush_lsn() { return MakeIndirectExec<true, true>(&pg_current_wal_flush_lsn); }
+TExecFunc arrow_pg_current_wal_insert_lsn() { return MakeIndirectExec<true, true>(&pg_current_wal_insert_lsn); }
+TExecFunc arrow_pg_current_wal_lsn() { return MakeIndirectExec<true, true>(&pg_current_wal_lsn); }
+TExecFunc arrow_pg_database_size_name() { return MakeIndirectExec<true, true>(&pg_database_size_name); }
+TExecFunc arrow_pg_database_size_oid() { return MakeIndirectExec<true, true>(&pg_database_size_oid); }
+TExecFunc arrow_pg_ddl_command_in() { return MakeIndirectExec<true, true>(&pg_ddl_command_in); }
+TExecFunc arrow_pg_ddl_command_out() { return MakeIndirectExec<true, false>(&pg_ddl_command_out); }
+TExecFunc arrow_pg_ddl_command_recv() { return MakeIndirectExec<true, true>(&pg_ddl_command_recv); }
+TExecFunc arrow_pg_ddl_command_send() { return MakeIndirectExec<true, false>(&pg_ddl_command_send); }
+TExecFunc arrow_pg_extension_config_dump() { return MakeIndirectExec<true, true>(&pg_extension_config_dump); }
+TExecFunc arrow_pg_filenode_relation() { return MakeIndirectExec<true, true>(&pg_filenode_relation); }
+TExecFunc arrow_pg_function_is_visible() { return MakeIndirectExec<true, true>(&pg_function_is_visible); }
+TExecFunc arrow_pg_get_constraintdef() { return MakeIndirectExec<true, false>(&pg_get_constraintdef); }
+TExecFunc arrow_pg_get_constraintdef_ext() { return MakeIndirectExec<true, false>(&pg_get_constraintdef_ext); }
+TExecFunc arrow_pg_get_expr() { return MakeIndirectExec<true, false>(&pg_get_expr); }
+TExecFunc arrow_pg_get_expr_ext() { return MakeIndirectExec<true, false>(&pg_get_expr_ext); }
+TExecFunc arrow_pg_get_function_arg_default() { return MakeIndirectExec<true, false>(&pg_get_function_arg_default); }
+TExecFunc arrow_pg_get_function_arguments() { return MakeIndirectExec<true, false>(&pg_get_function_arguments); }
+TExecFunc arrow_pg_get_function_identity_arguments() { return MakeIndirectExec<true, false>(&pg_get_function_identity_arguments); }
+TExecFunc arrow_pg_get_function_result() { return MakeIndirectExec<true, false>(&pg_get_function_result); }
+TExecFunc arrow_pg_get_function_sqlbody() { return MakeIndirectExec<true, false>(&pg_get_function_sqlbody); }
+TExecFunc arrow_pg_get_functiondef() { return MakeIndirectExec<true, false>(&pg_get_functiondef); }
+TExecFunc arrow_pg_get_indexdef() { return MakeIndirectExec<true, false>(&pg_get_indexdef); }
+TExecFunc arrow_pg_get_indexdef_ext() { return MakeIndirectExec<true, false>(&pg_get_indexdef_ext); }
+TExecFunc arrow_pg_get_partition_constraintdef() { return MakeIndirectExec<true, false>(&pg_get_partition_constraintdef); }
+TExecFunc arrow_pg_get_partkeydef() { return MakeIndirectExec<true, false>(&pg_get_partkeydef); }
+TExecFunc arrow_pg_get_ruledef() { return MakeIndirectExec<true, false>(&pg_get_ruledef); }
+TExecFunc arrow_pg_get_ruledef_ext() { return MakeIndirectExec<true, false>(&pg_get_ruledef_ext); }
+TExecFunc arrow_pg_get_serial_sequence() { return MakeIndirectExec<true, false>(&pg_get_serial_sequence); }
+TExecFunc arrow_pg_get_statisticsobjdef() { return MakeIndirectExec<true, false>(&pg_get_statisticsobjdef); }
+TExecFunc arrow_pg_get_statisticsobjdef_columns() { return MakeIndirectExec<true, false>(&pg_get_statisticsobjdef_columns); }
+TExecFunc arrow_pg_get_statisticsobjdef_expressions() { return MakeIndirectExec<true, false>(&pg_get_statisticsobjdef_expressions); }
+TExecFunc arrow_pg_get_triggerdef() { return MakeIndirectExec<true, false>(&pg_get_triggerdef); }
+TExecFunc arrow_pg_get_triggerdef_ext() { return MakeIndirectExec<true, false>(&pg_get_triggerdef_ext); }
+TExecFunc arrow_pg_get_userbyid() { return MakeIndirectExec<true, false>(&pg_get_userbyid); }
+TExecFunc arrow_pg_get_viewdef() { return MakeIndirectExec<true, false>(&pg_get_viewdef); }
+TExecFunc arrow_pg_get_viewdef_ext() { return MakeIndirectExec<true, false>(&pg_get_viewdef_ext); }
+TExecFunc arrow_pg_get_viewdef_name() { return MakeIndirectExec<true, false>(&pg_get_viewdef_name); }
+TExecFunc arrow_pg_get_viewdef_name_ext() { return MakeIndirectExec<true, false>(&pg_get_viewdef_name_ext); }
+TExecFunc arrow_pg_get_viewdef_wrap() { return MakeIndirectExec<true, false>(&pg_get_viewdef_wrap); }
+TExecFunc arrow_pg_get_wal_replay_pause_state() { return MakeIndirectExec<true, false>(&pg_get_wal_replay_pause_state); }
+TExecFunc arrow_pg_index_column_has_property() { return MakeIndirectExec<true, true>(&pg_index_column_has_property); }
+TExecFunc arrow_pg_index_has_property() { return MakeIndirectExec<true, true>(&pg_index_has_property); }
+TExecFunc arrow_pg_indexam_has_property() { return MakeIndirectExec<true, true>(&pg_indexam_has_property); }
+TExecFunc arrow_pg_indexam_progress_phasename() { return MakeIndirectExec<true, false>(&pg_indexam_progress_phasename); }
+TExecFunc arrow_pg_indexes_size() { return MakeIndirectExec<true, true>(&pg_indexes_size); }
+TExecFunc arrow_pg_is_in_backup() { return MakeIndirectExec<true, true>(&pg_is_in_backup); }
+TExecFunc arrow_pg_is_in_recovery() { return MakeIndirectExec<true, true>(&pg_is_in_recovery); }
+TExecFunc arrow_pg_is_other_temp_schema() { return MakeIndirectExec<true, true>(&pg_is_other_temp_schema); }
+TExecFunc arrow_pg_is_wal_replay_paused() { return MakeIndirectExec<true, true>(&pg_is_wal_replay_paused); }
+TExecFunc arrow_pg_jit_available() { return MakeIndirectExec<true, true>(&pg_jit_available); }
+TExecFunc arrow_pg_last_wal_receive_lsn() { return MakeIndirectExec<true, true>(&pg_last_wal_receive_lsn); }
+TExecFunc arrow_pg_last_wal_replay_lsn() { return MakeIndirectExec<true, true>(&pg_last_wal_replay_lsn); }
+TExecFunc arrow_pg_last_xact_replay_timestamp() { return MakeIndirectExec<true, true>(&pg_last_xact_replay_timestamp); }
+TExecFunc arrow_pg_lsn_cmp() { return MakeIndirectExec<true, true>(&pg_lsn_cmp); }
+TExecFunc arrow_pg_lsn_eq() { return MakeIndirectExec<true, true>(&pg_lsn_eq); }
+TExecFunc arrow_pg_lsn_ge() { return MakeIndirectExec<true, true>(&pg_lsn_ge); }
+TExecFunc arrow_pg_lsn_gt() { return MakeIndirectExec<true, true>(&pg_lsn_gt); }
+TExecFunc arrow_pg_lsn_hash() { return MakeIndirectExec<true, true>(&pg_lsn_hash); }
+TExecFunc arrow_pg_lsn_hash_extended() { return MakeIndirectExec<true, true>(&pg_lsn_hash_extended); }
+TExecFunc arrow_pg_lsn_in() { return MakeIndirectExec<true, true>(&pg_lsn_in); }
+TExecFunc arrow_pg_lsn_larger() { return MakeIndirectExec<true, true>(&pg_lsn_larger); }
+TExecFunc arrow_pg_lsn_le() { return MakeIndirectExec<true, true>(&pg_lsn_le); }
+TExecFunc arrow_pg_lsn_lt() { return MakeIndirectExec<true, true>(&pg_lsn_lt); }
+TExecFunc arrow_pg_lsn_mi() { return MakeIndirectExec<true, false>(&pg_lsn_mi); }
+TExecFunc arrow_pg_lsn_mii() { return MakeIndirectExec<true, true>(&pg_lsn_mii); }
+TExecFunc arrow_pg_lsn_ne() { return MakeIndirectExec<true, true>(&pg_lsn_ne); }
+TExecFunc arrow_pg_lsn_out() { return MakeIndirectExec<true, false>(&pg_lsn_out); }
+TExecFunc arrow_pg_lsn_pli() { return MakeIndirectExec<true, true>(&pg_lsn_pli); }
+TExecFunc arrow_pg_lsn_recv() { return MakeIndirectExec<true, true>(&pg_lsn_recv); }
+TExecFunc arrow_pg_lsn_send() { return MakeIndirectExec<true, false>(&pg_lsn_send); }
+TExecFunc arrow_pg_lsn_smaller() { return MakeIndirectExec<true, true>(&pg_lsn_smaller); }
+TExecFunc arrow_pg_my_temp_schema() { return MakeIndirectExec<true, true>(&pg_my_temp_schema); }
+TExecFunc arrow_pg_node_tree_in() { return MakeIndirectExec<true, false>(&pg_node_tree_in); }
+TExecFunc arrow_pg_node_tree_out() { return MakeIndirectExec<true, false>(&pg_node_tree_out); }
+TExecFunc arrow_pg_node_tree_recv() { return MakeIndirectExec<true, false>(&pg_node_tree_recv); }
+TExecFunc arrow_pg_node_tree_send() { return MakeIndirectExec<true, false>(&pg_node_tree_send); }
+TExecFunc arrow_pg_opclass_is_visible() { return MakeIndirectExec<true, true>(&pg_opclass_is_visible); }
+TExecFunc arrow_pg_operator_is_visible() { return MakeIndirectExec<true, true>(&pg_operator_is_visible); }
+TExecFunc arrow_pg_opfamily_is_visible() { return MakeIndirectExec<true, true>(&pg_opfamily_is_visible); }
+TExecFunc arrow_pg_promote() { return MakeIndirectExec<true, true>(&pg_promote); }
+TExecFunc arrow_pg_relation_filenode() { return MakeIndirectExec<true, true>(&pg_relation_filenode); }
+TExecFunc arrow_pg_relation_filepath() { return MakeIndirectExec<true, false>(&pg_relation_filepath); }
+TExecFunc arrow_pg_relation_size() { return MakeIndirectExec<true, true>(&pg_relation_size); }
+TExecFunc arrow_pg_sequence_last_value() { return MakeIndirectExec<true, true>(&pg_sequence_last_value); }
+TExecFunc arrow_pg_sequence_parameters() { return MakeIndirectExec<true, false>(&pg_sequence_parameters); }
+TExecFunc arrow_pg_size_bytes() { return MakeIndirectExec<true, true>(&pg_size_bytes); }
+TExecFunc arrow_pg_size_pretty() { return MakeIndirectExec<true, false>(&pg_size_pretty); }
+TExecFunc arrow_pg_size_pretty_numeric() { return MakeIndirectExec<true, false>(&pg_size_pretty_numeric); }
+TExecFunc arrow_pg_start_backup() { return MakeIndirectExec<true, true>(&pg_start_backup); }
+TExecFunc arrow_pg_stat_clear_snapshot() { return MakeIndirectExec<false, true>(&pg_stat_clear_snapshot); }
+TExecFunc arrow_pg_stat_get_analyze_count() { return MakeIndirectExec<true, true>(&pg_stat_get_analyze_count); }
+TExecFunc arrow_pg_stat_get_archiver() { return MakeIndirectExec<false, false>(&pg_stat_get_archiver); }
+TExecFunc arrow_pg_stat_get_autoanalyze_count() { return MakeIndirectExec<true, true>(&pg_stat_get_autoanalyze_count); }
+TExecFunc arrow_pg_stat_get_autovacuum_count() { return MakeIndirectExec<true, true>(&pg_stat_get_autovacuum_count); }
+TExecFunc arrow_pg_stat_get_backend_activity() { return MakeIndirectExec<true, false>(&pg_stat_get_backend_activity); }
+TExecFunc arrow_pg_stat_get_backend_activity_start() { return MakeIndirectExec<true, true>(&pg_stat_get_backend_activity_start); }
+TExecFunc arrow_pg_stat_get_backend_client_addr() { return MakeIndirectExec<true, false>(&pg_stat_get_backend_client_addr); }
+TExecFunc arrow_pg_stat_get_backend_client_port() { return MakeIndirectExec<true, true>(&pg_stat_get_backend_client_port); }
+TExecFunc arrow_pg_stat_get_backend_dbid() { return MakeIndirectExec<true, true>(&pg_stat_get_backend_dbid); }
+TExecFunc arrow_pg_stat_get_backend_pid() { return MakeIndirectExec<true, true>(&pg_stat_get_backend_pid); }
+TExecFunc arrow_pg_stat_get_backend_start() { return MakeIndirectExec<true, true>(&pg_stat_get_backend_start); }
+TExecFunc arrow_pg_stat_get_backend_userid() { return MakeIndirectExec<true, true>(&pg_stat_get_backend_userid); }
+TExecFunc arrow_pg_stat_get_backend_wait_event() { return MakeIndirectExec<true, false>(&pg_stat_get_backend_wait_event); }
+TExecFunc arrow_pg_stat_get_backend_wait_event_type() { return MakeIndirectExec<true, false>(&pg_stat_get_backend_wait_event_type); }
+TExecFunc arrow_pg_stat_get_backend_xact_start() { return MakeIndirectExec<true, true>(&pg_stat_get_backend_xact_start); }
+TExecFunc arrow_pg_stat_get_bgwriter_buf_written_checkpoints() { return MakeIndirectExec<true, true>(&pg_stat_get_bgwriter_buf_written_checkpoints); }
+TExecFunc arrow_pg_stat_get_bgwriter_buf_written_clean() { return MakeIndirectExec<true, true>(&pg_stat_get_bgwriter_buf_written_clean); }
+TExecFunc arrow_pg_stat_get_bgwriter_maxwritten_clean() { return MakeIndirectExec<true, true>(&pg_stat_get_bgwriter_maxwritten_clean); }
+TExecFunc arrow_pg_stat_get_bgwriter_requested_checkpoints() { return MakeIndirectExec<true, true>(&pg_stat_get_bgwriter_requested_checkpoints); }
+TExecFunc arrow_pg_stat_get_bgwriter_stat_reset_time() { return MakeIndirectExec<true, true>(&pg_stat_get_bgwriter_stat_reset_time); }
+TExecFunc arrow_pg_stat_get_bgwriter_timed_checkpoints() { return MakeIndirectExec<true, true>(&pg_stat_get_bgwriter_timed_checkpoints); }
+TExecFunc arrow_pg_stat_get_blocks_fetched() { return MakeIndirectExec<true, true>(&pg_stat_get_blocks_fetched); }
+TExecFunc arrow_pg_stat_get_blocks_hit() { return MakeIndirectExec<true, true>(&pg_stat_get_blocks_hit); }
+TExecFunc arrow_pg_stat_get_buf_alloc() { return MakeIndirectExec<true, true>(&pg_stat_get_buf_alloc); }
+TExecFunc arrow_pg_stat_get_buf_fsync_backend() { return MakeIndirectExec<true, true>(&pg_stat_get_buf_fsync_backend); }
+TExecFunc arrow_pg_stat_get_buf_written_backend() { return MakeIndirectExec<true, true>(&pg_stat_get_buf_written_backend); }
+TExecFunc arrow_pg_stat_get_checkpoint_sync_time() { return MakeIndirectExec<true, true>(&pg_stat_get_checkpoint_sync_time); }
+TExecFunc arrow_pg_stat_get_checkpoint_write_time() { return MakeIndirectExec<true, true>(&pg_stat_get_checkpoint_write_time); }
+TExecFunc arrow_pg_stat_get_db_active_time() { return MakeIndirectExec<true, true>(&pg_stat_get_db_active_time); }
+TExecFunc arrow_pg_stat_get_db_blk_read_time() { return MakeIndirectExec<true, true>(&pg_stat_get_db_blk_read_time); }
+TExecFunc arrow_pg_stat_get_db_blk_write_time() { return MakeIndirectExec<true, true>(&pg_stat_get_db_blk_write_time); }
+TExecFunc arrow_pg_stat_get_db_blocks_fetched() { return MakeIndirectExec<true, true>(&pg_stat_get_db_blocks_fetched); }
+TExecFunc arrow_pg_stat_get_db_blocks_hit() { return MakeIndirectExec<true, true>(&pg_stat_get_db_blocks_hit); }
+TExecFunc arrow_pg_stat_get_db_checksum_failures() { return MakeIndirectExec<true, true>(&pg_stat_get_db_checksum_failures); }
+TExecFunc arrow_pg_stat_get_db_checksum_last_failure() { return MakeIndirectExec<true, true>(&pg_stat_get_db_checksum_last_failure); }
+TExecFunc arrow_pg_stat_get_db_conflict_all() { return MakeIndirectExec<true, true>(&pg_stat_get_db_conflict_all); }
+TExecFunc arrow_pg_stat_get_db_conflict_bufferpin() { return MakeIndirectExec<true, true>(&pg_stat_get_db_conflict_bufferpin); }
+TExecFunc arrow_pg_stat_get_db_conflict_lock() { return MakeIndirectExec<true, true>(&pg_stat_get_db_conflict_lock); }
+TExecFunc arrow_pg_stat_get_db_conflict_snapshot() { return MakeIndirectExec<true, true>(&pg_stat_get_db_conflict_snapshot); }
+TExecFunc arrow_pg_stat_get_db_conflict_startup_deadlock() { return MakeIndirectExec<true, true>(&pg_stat_get_db_conflict_startup_deadlock); }
+TExecFunc arrow_pg_stat_get_db_conflict_tablespace() { return MakeIndirectExec<true, true>(&pg_stat_get_db_conflict_tablespace); }
+TExecFunc arrow_pg_stat_get_db_deadlocks() { return MakeIndirectExec<true, true>(&pg_stat_get_db_deadlocks); }
+TExecFunc arrow_pg_stat_get_db_idle_in_transaction_time() { return MakeIndirectExec<true, true>(&pg_stat_get_db_idle_in_transaction_time); }
+TExecFunc arrow_pg_stat_get_db_numbackends() { return MakeIndirectExec<true, true>(&pg_stat_get_db_numbackends); }
+TExecFunc arrow_pg_stat_get_db_session_time() { return MakeIndirectExec<true, true>(&pg_stat_get_db_session_time); }
+TExecFunc arrow_pg_stat_get_db_sessions() { return MakeIndirectExec<true, true>(&pg_stat_get_db_sessions); }
+TExecFunc arrow_pg_stat_get_db_sessions_abandoned() { return MakeIndirectExec<true, true>(&pg_stat_get_db_sessions_abandoned); }
+TExecFunc arrow_pg_stat_get_db_sessions_fatal() { return MakeIndirectExec<true, true>(&pg_stat_get_db_sessions_fatal); }
+TExecFunc arrow_pg_stat_get_db_sessions_killed() { return MakeIndirectExec<true, true>(&pg_stat_get_db_sessions_killed); }
+TExecFunc arrow_pg_stat_get_db_stat_reset_time() { return MakeIndirectExec<true, true>(&pg_stat_get_db_stat_reset_time); }
+TExecFunc arrow_pg_stat_get_db_temp_bytes() { return MakeIndirectExec<true, true>(&pg_stat_get_db_temp_bytes); }
+TExecFunc arrow_pg_stat_get_db_temp_files() { return MakeIndirectExec<true, true>(&pg_stat_get_db_temp_files); }
+TExecFunc arrow_pg_stat_get_db_tuples_deleted() { return MakeIndirectExec<true, true>(&pg_stat_get_db_tuples_deleted); }
+TExecFunc arrow_pg_stat_get_db_tuples_fetched() { return MakeIndirectExec<true, true>(&pg_stat_get_db_tuples_fetched); }
+TExecFunc arrow_pg_stat_get_db_tuples_inserted() { return MakeIndirectExec<true, true>(&pg_stat_get_db_tuples_inserted); }
+TExecFunc arrow_pg_stat_get_db_tuples_returned() { return MakeIndirectExec<true, true>(&pg_stat_get_db_tuples_returned); }
+TExecFunc arrow_pg_stat_get_db_tuples_updated() { return MakeIndirectExec<true, true>(&pg_stat_get_db_tuples_updated); }
+TExecFunc arrow_pg_stat_get_db_xact_commit() { return MakeIndirectExec<true, true>(&pg_stat_get_db_xact_commit); }
+TExecFunc arrow_pg_stat_get_db_xact_rollback() { return MakeIndirectExec<true, true>(&pg_stat_get_db_xact_rollback); }
+TExecFunc arrow_pg_stat_get_dead_tuples() { return MakeIndirectExec<true, true>(&pg_stat_get_dead_tuples); }
+TExecFunc arrow_pg_stat_get_function_calls() { return MakeIndirectExec<true, true>(&pg_stat_get_function_calls); }
+TExecFunc arrow_pg_stat_get_function_self_time() { return MakeIndirectExec<true, true>(&pg_stat_get_function_self_time); }
+TExecFunc arrow_pg_stat_get_function_total_time() { return MakeIndirectExec<true, true>(&pg_stat_get_function_total_time); }
+TExecFunc arrow_pg_stat_get_ins_since_vacuum() { return MakeIndirectExec<true, true>(&pg_stat_get_ins_since_vacuum); }
+TExecFunc arrow_pg_stat_get_last_analyze_time() { return MakeIndirectExec<true, true>(&pg_stat_get_last_analyze_time); }
+TExecFunc arrow_pg_stat_get_last_autoanalyze_time() { return MakeIndirectExec<true, true>(&pg_stat_get_last_autoanalyze_time); }
+TExecFunc arrow_pg_stat_get_last_autovacuum_time() { return MakeIndirectExec<true, true>(&pg_stat_get_last_autovacuum_time); }
+TExecFunc arrow_pg_stat_get_last_vacuum_time() { return MakeIndirectExec<true, true>(&pg_stat_get_last_vacuum_time); }
+TExecFunc arrow_pg_stat_get_live_tuples() { return MakeIndirectExec<true, true>(&pg_stat_get_live_tuples); }
+TExecFunc arrow_pg_stat_get_mod_since_analyze() { return MakeIndirectExec<true, true>(&pg_stat_get_mod_since_analyze); }
+TExecFunc arrow_pg_stat_get_numscans() { return MakeIndirectExec<true, true>(&pg_stat_get_numscans); }
+TExecFunc arrow_pg_stat_get_snapshot_timestamp() { return MakeIndirectExec<true, true>(&pg_stat_get_snapshot_timestamp); }
+TExecFunc arrow_pg_stat_get_tuples_deleted() { return MakeIndirectExec<true, true>(&pg_stat_get_tuples_deleted); }
+TExecFunc arrow_pg_stat_get_tuples_fetched() { return MakeIndirectExec<true, true>(&pg_stat_get_tuples_fetched); }
+TExecFunc arrow_pg_stat_get_tuples_hot_updated() { return MakeIndirectExec<true, true>(&pg_stat_get_tuples_hot_updated); }
+TExecFunc arrow_pg_stat_get_tuples_inserted() { return MakeIndirectExec<true, true>(&pg_stat_get_tuples_inserted); }
+TExecFunc arrow_pg_stat_get_tuples_returned() { return MakeIndirectExec<true, true>(&pg_stat_get_tuples_returned); }
+TExecFunc arrow_pg_stat_get_tuples_updated() { return MakeIndirectExec<true, true>(&pg_stat_get_tuples_updated); }
+TExecFunc arrow_pg_stat_get_vacuum_count() { return MakeIndirectExec<true, true>(&pg_stat_get_vacuum_count); }
+TExecFunc arrow_pg_stat_get_wal() { return MakeIndirectExec<false, false>(&pg_stat_get_wal); }
+TExecFunc arrow_pg_stat_get_xact_blocks_fetched() { return MakeIndirectExec<true, true>(&pg_stat_get_xact_blocks_fetched); }
+TExecFunc arrow_pg_stat_get_xact_blocks_hit() { return MakeIndirectExec<true, true>(&pg_stat_get_xact_blocks_hit); }
+TExecFunc arrow_pg_stat_get_xact_function_calls() { return MakeIndirectExec<true, true>(&pg_stat_get_xact_function_calls); }
+TExecFunc arrow_pg_stat_get_xact_function_self_time() { return MakeIndirectExec<true, true>(&pg_stat_get_xact_function_self_time); }
+TExecFunc arrow_pg_stat_get_xact_function_total_time() { return MakeIndirectExec<true, true>(&pg_stat_get_xact_function_total_time); }
+TExecFunc arrow_pg_stat_get_xact_numscans() { return MakeIndirectExec<true, true>(&pg_stat_get_xact_numscans); }
+TExecFunc arrow_pg_stat_get_xact_tuples_deleted() { return MakeIndirectExec<true, true>(&pg_stat_get_xact_tuples_deleted); }
+TExecFunc arrow_pg_stat_get_xact_tuples_fetched() { return MakeIndirectExec<true, true>(&pg_stat_get_xact_tuples_fetched); }
+TExecFunc arrow_pg_stat_get_xact_tuples_hot_updated() { return MakeIndirectExec<true, true>(&pg_stat_get_xact_tuples_hot_updated); }
+TExecFunc arrow_pg_stat_get_xact_tuples_inserted() { return MakeIndirectExec<true, true>(&pg_stat_get_xact_tuples_inserted); }
+TExecFunc arrow_pg_stat_get_xact_tuples_returned() { return MakeIndirectExec<true, true>(&pg_stat_get_xact_tuples_returned); }
+TExecFunc arrow_pg_stat_get_xact_tuples_updated() { return MakeIndirectExec<true, true>(&pg_stat_get_xact_tuples_updated); }
+TExecFunc arrow_pg_stat_reset() { return MakeIndirectExec<false, true>(&pg_stat_reset); }
+TExecFunc arrow_pg_stat_reset_replication_slot() { return MakeIndirectExec<false, true>(&pg_stat_reset_replication_slot); }
+TExecFunc arrow_pg_stat_reset_shared() { return MakeIndirectExec<true, true>(&pg_stat_reset_shared); }
+TExecFunc arrow_pg_stat_reset_single_function_counters() { return MakeIndirectExec<true, true>(&pg_stat_reset_single_function_counters); }
+TExecFunc arrow_pg_stat_reset_single_table_counters() { return MakeIndirectExec<true, true>(&pg_stat_reset_single_table_counters); }
+TExecFunc arrow_pg_stat_reset_slru() { return MakeIndirectExec<false, true>(&pg_stat_reset_slru); }
+TExecFunc arrow_pg_statistics_obj_is_visible() { return MakeIndirectExec<true, true>(&pg_statistics_obj_is_visible); }
+TExecFunc arrow_pg_stop_backup() { return MakeIndirectExec<true, true>(&pg_stop_backup); }
+TExecFunc arrow_pg_switch_wal() { return MakeIndirectExec<true, true>(&pg_switch_wal); }
+TExecFunc arrow_pg_table_is_visible() { return MakeIndirectExec<true, true>(&pg_table_is_visible); }
+TExecFunc arrow_pg_table_size() { return MakeIndirectExec<true, true>(&pg_table_size); }
+TExecFunc arrow_pg_tablespace_size_name() { return MakeIndirectExec<true, true>(&pg_tablespace_size_name); }
+TExecFunc arrow_pg_tablespace_size_oid() { return MakeIndirectExec<true, true>(&pg_tablespace_size_oid); }
+TExecFunc arrow_pg_total_relation_size() { return MakeIndirectExec<true, true>(&pg_total_relation_size); }
+TExecFunc arrow_pg_trigger_depth() { return MakeIndirectExec<true, true>(&pg_trigger_depth); }
+TExecFunc arrow_pg_ts_config_is_visible() { return MakeIndirectExec<true, true>(&pg_ts_config_is_visible); }
+TExecFunc arrow_pg_ts_dict_is_visible() { return MakeIndirectExec<true, true>(&pg_ts_dict_is_visible); }
+TExecFunc arrow_pg_ts_parser_is_visible() { return MakeIndirectExec<true, true>(&pg_ts_parser_is_visible); }
+TExecFunc arrow_pg_ts_template_is_visible() { return MakeIndirectExec<true, true>(&pg_ts_template_is_visible); }
+TExecFunc arrow_pg_type_is_visible() { return MakeIndirectExec<true, true>(&pg_type_is_visible); }
+TExecFunc arrow_pg_wal_lsn_diff() { return MakeIndirectExec<true, false>(&pg_wal_lsn_diff); }
+TExecFunc arrow_pg_wal_replay_pause() { return MakeIndirectExec<true, true>(&pg_wal_replay_pause); }
+TExecFunc arrow_pg_wal_replay_resume() { return MakeIndirectExec<true, true>(&pg_wal_replay_resume); }
+TExecFunc arrow_pg_walfile_name() { return MakeIndirectExec<true, false>(&pg_walfile_name); }
+TExecFunc arrow_pg_walfile_name_offset() { return MakeIndirectExec<true, false>(&pg_walfile_name_offset); }
+TExecFunc arrow_prsd_end() { return MakeIndirectExec<true, true>(&prsd_end); }
+TExecFunc arrow_prsd_headline() { return MakeIndirectExec<true, true>(&prsd_headline); }
+TExecFunc arrow_prsd_lextype() { return MakeIndirectExec<true, true>(&prsd_lextype); }
+TExecFunc arrow_prsd_nexttoken() { return MakeIndirectExec<true, true>(&prsd_nexttoken); }
+TExecFunc arrow_prsd_start() { return MakeIndirectExec<true, true>(&prsd_start); }
+TExecFunc arrow_radians() { return MakeIndirectExec<true, true>(&radians); }
+TExecFunc arrow_range_adjacent_multirange() { return MakeIndirectExec<true, true>(&range_adjacent_multirange); }
+TExecFunc arrow_range_after_multirange() { return MakeIndirectExec<true, true>(&range_after_multirange); }
+TExecFunc arrow_range_agg_finalfn() { return MakeIndirectExec<false, false>(&range_agg_finalfn); }
+TExecFunc arrow_range_agg_transfn() { return MakeIndirectExec<false, true>(&range_agg_transfn); }
+TExecFunc arrow_range_before_multirange() { return MakeIndirectExec<true, true>(&range_before_multirange); }
+TExecFunc arrow_range_contained_by_multirange() { return MakeIndirectExec<true, true>(&range_contained_by_multirange); }
+TExecFunc arrow_range_contains_multirange() { return MakeIndirectExec<true, true>(&range_contains_multirange); }
+TExecFunc arrow_range_merge_from_multirange() { return MakeIndirectExec<true, false>(&range_merge_from_multirange); }
+TExecFunc arrow_range_overlaps_multirange() { return MakeIndirectExec<true, true>(&range_overlaps_multirange); }
+TExecFunc arrow_range_overleft_multirange() { return MakeIndirectExec<true, true>(&range_overleft_multirange); }
+TExecFunc arrow_range_overright_multirange() { return MakeIndirectExec<true, true>(&range_overright_multirange); }
+TExecFunc arrow_rangesel() { return MakeIndirectExec<true, true>(&rangesel); }
+TExecFunc arrow_record_eq() { return MakeIndirectExec<true, true>(&record_eq); }
+TExecFunc arrow_record_ge() { return MakeIndirectExec<true, true>(&record_ge); }
+TExecFunc arrow_record_gt() { return MakeIndirectExec<true, true>(&record_gt); }
+TExecFunc arrow_record_image_eq() { return MakeIndirectExec<true, true>(&record_image_eq); }
+TExecFunc arrow_record_image_ge() { return MakeIndirectExec<true, true>(&record_image_ge); }
+TExecFunc arrow_record_image_gt() { return MakeIndirectExec<true, true>(&record_image_gt); }
+TExecFunc arrow_record_image_le() { return MakeIndirectExec<true, true>(&record_image_le); }
+TExecFunc arrow_record_image_lt() { return MakeIndirectExec<true, true>(&record_image_lt); }
+TExecFunc arrow_record_image_ne() { return MakeIndirectExec<true, true>(&record_image_ne); }
+TExecFunc arrow_record_in() { return MakeIndirectExec<true, false>(&record_in); }
+TExecFunc arrow_record_le() { return MakeIndirectExec<true, true>(&record_le); }
+TExecFunc arrow_record_lt() { return MakeIndirectExec<true, true>(&record_lt); }
+TExecFunc arrow_record_ne() { return MakeIndirectExec<true, true>(&record_ne); }
+TExecFunc arrow_record_out() { return MakeIndirectExec<true, false>(&record_out); }
+TExecFunc arrow_record_recv() { return MakeIndirectExec<true, false>(&record_recv); }
+TExecFunc arrow_record_send() { return MakeIndirectExec<true, false>(&record_send); }
+TExecFunc arrow_session_user() { return MakeIndirectExec<true, false>(&session_user); }
+TExecFunc arrow_setseed() { return MakeIndirectExec<true, true>(&setseed); }
+TExecFunc arrow_setval3_oid() { return MakeIndirectExec<true, true>(&setval3_oid); }
+TExecFunc arrow_setval_oid() { return MakeIndirectExec<true, true>(&setval_oid); }
+TExecFunc arrow_shell_in() { return MakeIndirectExec<false, true>(&shell_in); }
+TExecFunc arrow_shell_out() { return MakeIndirectExec<true, false>(&shell_out); }
+TExecFunc arrow_spg_kd_choose() { return MakeIndirectExec<true, true>(&spg_kd_choose); }
+TExecFunc arrow_spg_kd_config() { return MakeIndirectExec<true, true>(&spg_kd_config); }
+TExecFunc arrow_spg_kd_inner_consistent() { return MakeIndirectExec<true, true>(&spg_kd_inner_consistent); }
+TExecFunc arrow_spg_kd_picksplit() { return MakeIndirectExec<true, true>(&spg_kd_picksplit); }
+TExecFunc arrow_spg_quad_choose() { return MakeIndirectExec<true, true>(&spg_quad_choose); }
+TExecFunc arrow_spg_quad_config() { return MakeIndirectExec<true, true>(&spg_quad_config); }
+TExecFunc arrow_spg_quad_inner_consistent() { return MakeIndirectExec<true, true>(&spg_quad_inner_consistent); }
+TExecFunc arrow_spg_quad_leaf_consistent() { return MakeIndirectExec<true, true>(&spg_quad_leaf_consistent); }
+TExecFunc arrow_spg_quad_picksplit() { return MakeIndirectExec<true, true>(&spg_quad_picksplit); }
+TExecFunc arrow_spg_text_choose() { return MakeIndirectExec<true, true>(&spg_text_choose); }
+TExecFunc arrow_spg_text_config() { return MakeIndirectExec<true, true>(&spg_text_config); }
+TExecFunc arrow_spg_text_inner_consistent() { return MakeIndirectExec<true, true>(&spg_text_inner_consistent); }
+TExecFunc arrow_spg_text_leaf_consistent() { return MakeIndirectExec<true, true>(&spg_text_leaf_consistent); }
+TExecFunc arrow_spg_text_picksplit() { return MakeIndirectExec<true, true>(&spg_text_picksplit); }
+TExecFunc arrow_spghandler() { return MakeIndirectExec<true, true>(&spghandler); }
+TExecFunc arrow_suppress_redundant_updates_trigger() { return MakeIndirectExec<true, true>(&suppress_redundant_updates_trigger); }
+TExecFunc arrow_table_am_handler_in() { return MakeIndirectExec<false, true>(&table_am_handler_in); }
+TExecFunc arrow_table_am_handler_out() { return MakeIndirectExec<true, false>(&table_am_handler_out); }
+TExecFunc arrow_trigger_in() { return MakeIndirectExec<false, true>(&trigger_in); }
+TExecFunc arrow_trigger_out() { return MakeIndirectExec<true, false>(&trigger_out); }
+TExecFunc arrow_tsm_handler_in() { return MakeIndirectExec<false, true>(&tsm_handler_in); }
+TExecFunc arrow_tsm_handler_out() { return MakeIndirectExec<true, false>(&tsm_handler_out); }
+TExecFunc arrow_tsm_system_handler() { return MakeIndirectExec<true, true>(&tsm_system_handler); }
+TExecFunc arrow_tsq_mcontained() { return MakeIndirectExec<true, true>(&tsq_mcontained); }
+TExecFunc arrow_tsq_mcontains() { return MakeIndirectExec<true, true>(&tsq_mcontains); }
+TExecFunc arrow_tsquery_and() { return MakeIndirectExec<true, false>(&tsquery_and); }
+TExecFunc arrow_tsquery_cmp() { return MakeIndirectExec<true, true>(&tsquery_cmp); }
+TExecFunc arrow_tsquery_eq() { return MakeIndirectExec<true, true>(&tsquery_eq); }
+TExecFunc arrow_tsquery_ge() { return MakeIndirectExec<true, true>(&tsquery_ge); }
+TExecFunc arrow_tsquery_gt() { return MakeIndirectExec<true, true>(&tsquery_gt); }
+TExecFunc arrow_tsquery_le() { return MakeIndirectExec<true, true>(&tsquery_le); }
+TExecFunc arrow_tsquery_lt() { return MakeIndirectExec<true, true>(&tsquery_lt); }
+TExecFunc arrow_tsquery_ne() { return MakeIndirectExec<true, true>(&tsquery_ne); }
+TExecFunc arrow_tsquery_not() { return MakeIndirectExec<true, false>(&tsquery_not); }
+TExecFunc arrow_tsquery_numnode() { return MakeIndirectExec<true, true>(&tsquery_numnode); }
+TExecFunc arrow_tsquery_or() { return MakeIndirectExec<true, false>(&tsquery_or); }
+TExecFunc arrow_tsquery_phrase() { return MakeIndirectExec<true, false>(&tsquery_phrase); }
+TExecFunc arrow_tsquery_phrase_distance() { return MakeIndirectExec<true, false>(&tsquery_phrase_distance); }
+TExecFunc arrow_tsvectorin() { return MakeIndirectExec<true, false>(&tsvectorin); }
+TExecFunc arrow_tsvectorout() { return MakeIndirectExec<true, false>(&tsvectorout); }
+TExecFunc arrow_tsvectorrecv() { return MakeIndirectExec<true, false>(&tsvectorrecv); }
+TExecFunc arrow_tsvectorsend() { return MakeIndirectExec<true, false>(&tsvectorsend); }
+TExecFunc arrow_varchar() { return MakeIndirectExec<true, false>(&varchar); }
+TExecFunc arrow_varchar_support() { return MakeIndirectExec<true, true>(&varchar_support); }
+TExecFunc arrow_varcharin() { return MakeIndirectExec<true, false>(&varcharin); }
+TExecFunc arrow_varcharout() { return MakeIndirectExec<true, false>(&varcharout); }
+TExecFunc arrow_varcharrecv() { return MakeIndirectExec<true, false>(&varcharrecv); }
+TExecFunc arrow_varcharsend() { return MakeIndirectExec<true, false>(&varcharsend); }
+TExecFunc arrow_varchartypmodin() { return MakeIndirectExec<true, true>(&varchartypmodin); }
+TExecFunc arrow_varchartypmodout() { return MakeIndirectExec<true, false>(&varchartypmodout); }
+TExecFunc arrow_void_in() { return MakeIndirectExec<true, true>(&void_in); }
+TExecFunc arrow_void_out() { return MakeIndirectExec<true, false>(&void_out); }
+TExecFunc arrow_void_recv() { return MakeIndirectExec<true, true>(&void_recv); }
+TExecFunc arrow_void_send() { return MakeIndirectExec<true, false>(&void_send); }
+TExecFunc arrow_width_bucket_float8() { return MakeIndirectExec<true, true>(&width_bucket_float8); }
+TExecFunc arrow_xid8cmp() { return MakeIndirectExec<true, true>(&xid8cmp); }
+TExecFunc arrow_xid8eq() { return MakeIndirectExec<true, true>(&xid8eq); }
+TExecFunc arrow_xid8ge() { return MakeIndirectExec<true, true>(&xid8ge); }
+TExecFunc arrow_xid8gt() { return MakeIndirectExec<true, true>(&xid8gt); }
+TExecFunc arrow_xid8in() { return MakeIndirectExec<true, true>(&xid8in); }
+TExecFunc arrow_xid8le() { return MakeIndirectExec<true, true>(&xid8le); }
+TExecFunc arrow_xid8lt() { return MakeIndirectExec<true, true>(&xid8lt); }
+TExecFunc arrow_xid8ne() { return MakeIndirectExec<true, true>(&xid8ne); }
+TExecFunc arrow_xid8out() { return MakeIndirectExec<true, false>(&xid8out); }
+TExecFunc arrow_xid8recv() { return MakeIndirectExec<true, true>(&xid8recv); }
+TExecFunc arrow_xid8send() { return MakeIndirectExec<true, false>(&xid8send); }
+TExecFunc arrow_xid8toxid() { return MakeIndirectExec<true, true>(&xid8toxid); }
+TExecFunc arrow_xid_age() { return MakeIndirectExec<true, true>(&xid_age); }
+TExecFunc arrow_xideq() { return MakeIndirectExec<true, true>(&xideq); }
+TExecFunc arrow_xidin() { return MakeIndirectExec<true, true>(&xidin); }
+TExecFunc arrow_xidneq() { return MakeIndirectExec<true, true>(&xidneq); }
+TExecFunc arrow_xidout() { return MakeIndirectExec<true, false>(&xidout); }
+TExecFunc arrow_xidrecv() { return MakeIndirectExec<true, true>(&xidrecv); }
+TExecFunc arrow_xidsend() { return MakeIndirectExec<true, false>(&xidsend); }
diff --git a/ydb/library/yql/parser/pg_wrapper/pg_kernels.slow.3.inc b/ydb/library/yql/parser/pg_wrapper/pg_kernels.slow.3.inc
new file mode 100644
index 00000000000..42dea0d131f
--- /dev/null
+++ b/ydb/library/yql/parser/pg_wrapper/pg_kernels.slow.3.inc
@@ -0,0 +1,732 @@
+TExecFunc arrow_areajoinsel() { return MakeIndirectExec<true, true>(&areajoinsel); }
+TExecFunc arrow_areasel() { return MakeIndirectExec<true, true>(&areasel); }
+TExecFunc arrow_array_agg_array_finalfn() { return MakeIndirectExec<false, false>(&array_agg_array_finalfn); }
+TExecFunc arrow_array_agg_array_transfn() { return MakeIndirectExec<false, true>(&array_agg_array_transfn); }
+TExecFunc arrow_array_agg_finalfn() { return MakeIndirectExec<false, false>(&array_agg_finalfn); }
+TExecFunc arrow_array_agg_transfn() { return MakeIndirectExec<false, true>(&array_agg_transfn); }
+TExecFunc arrow_array_append() { return MakeIndirectExec<false, false>(&array_append); }
+TExecFunc arrow_array_cat() { return MakeIndirectExec<false, false>(&array_cat); }
+TExecFunc arrow_array_position() { return MakeIndirectExec<false, true>(&array_position); }
+TExecFunc arrow_array_position_start() { return MakeIndirectExec<false, true>(&array_position_start); }
+TExecFunc arrow_array_positions() { return MakeIndirectExec<false, false>(&array_positions); }
+TExecFunc arrow_array_prepend() { return MakeIndirectExec<false, false>(&array_prepend); }
+TExecFunc arrow_array_typanalyze() { return MakeIndirectExec<true, true>(&array_typanalyze); }
+TExecFunc arrow_binary_decode() { return MakeIndirectExec<true, false>(&binary_decode); }
+TExecFunc arrow_binary_encode() { return MakeIndirectExec<true, false>(&binary_encode); }
+TExecFunc arrow_bit() { return MakeIndirectExec<true, false>(&bit); }
+TExecFunc arrow_bit_and() { return MakeIndirectExec<true, false>(&bit_and); }
+TExecFunc arrow_bit_bit_count() { return MakeIndirectExec<true, true>(&bit_bit_count); }
+TExecFunc arrow_bit_in() { return MakeIndirectExec<true, false>(&bit_in); }
+TExecFunc arrow_bit_or() { return MakeIndirectExec<true, false>(&bit_or); }
+TExecFunc arrow_bit_out() { return MakeIndirectExec<true, false>(&bit_out); }
+TExecFunc arrow_bit_recv() { return MakeIndirectExec<true, false>(&bit_recv); }
+TExecFunc arrow_bit_send() { return MakeIndirectExec<true, false>(&bit_send); }
+TExecFunc arrow_bitcat() { return MakeIndirectExec<true, false>(&bitcat); }
+TExecFunc arrow_bitcmp() { return MakeIndirectExec<true, true>(&bitcmp); }
+TExecFunc arrow_biteq() { return MakeIndirectExec<true, true>(&biteq); }
+TExecFunc arrow_bitfromint4() { return MakeIndirectExec<true, false>(&bitfromint4); }
+TExecFunc arrow_bitfromint8() { return MakeIndirectExec<true, false>(&bitfromint8); }
+TExecFunc arrow_bitge() { return MakeIndirectExec<true, true>(&bitge); }
+TExecFunc arrow_bitgetbit() { return MakeIndirectExec<true, true>(&bitgetbit); }
+TExecFunc arrow_bitgt() { return MakeIndirectExec<true, true>(&bitgt); }
+TExecFunc arrow_bitle() { return MakeIndirectExec<true, true>(&bitle); }
+TExecFunc arrow_bitlength() { return MakeIndirectExec<true, true>(&bitlength); }
+TExecFunc arrow_bitlt() { return MakeIndirectExec<true, true>(&bitlt); }
+TExecFunc arrow_bitne() { return MakeIndirectExec<true, true>(&bitne); }
+TExecFunc arrow_bitnot() { return MakeIndirectExec<true, false>(&bitnot); }
+TExecFunc arrow_bitoctetlength() { return MakeIndirectExec<true, true>(&bitoctetlength); }
+TExecFunc arrow_bitoverlay() { return MakeIndirectExec<true, false>(&bitoverlay); }
+TExecFunc arrow_bitoverlay_no_len() { return MakeIndirectExec<true, false>(&bitoverlay_no_len); }
+TExecFunc arrow_bitposition() { return MakeIndirectExec<true, true>(&bitposition); }
+TExecFunc arrow_bitsetbit() { return MakeIndirectExec<true, false>(&bitsetbit); }
+TExecFunc arrow_bitshiftleft() { return MakeIndirectExec<true, false>(&bitshiftleft); }
+TExecFunc arrow_bitshiftright() { return MakeIndirectExec<true, false>(&bitshiftright); }
+TExecFunc arrow_bitsubstr() { return MakeIndirectExec<true, false>(&bitsubstr); }
+TExecFunc arrow_bitsubstr_no_len() { return MakeIndirectExec<true, false>(&bitsubstr_no_len); }
+TExecFunc arrow_bittoint4() { return MakeIndirectExec<true, true>(&bittoint4); }
+TExecFunc arrow_bittoint8() { return MakeIndirectExec<true, true>(&bittoint8); }
+TExecFunc arrow_bittypmodin() { return MakeIndirectExec<true, true>(&bittypmodin); }
+TExecFunc arrow_bittypmodout() { return MakeIndirectExec<true, false>(&bittypmodout); }
+TExecFunc arrow_bitxor() { return MakeIndirectExec<true, false>(&bitxor); }
+TExecFunc arrow_box_above() { return MakeIndirectExec<true, true>(&box_above); }
+TExecFunc arrow_box_above_eq() { return MakeIndirectExec<true, true>(&box_above_eq); }
+TExecFunc arrow_box_add() { return MakeIndirectExec<true, false>(&box_add); }
+TExecFunc arrow_box_area() { return MakeIndirectExec<true, true>(&box_area); }
+TExecFunc arrow_box_below() { return MakeIndirectExec<true, true>(&box_below); }
+TExecFunc arrow_box_below_eq() { return MakeIndirectExec<true, true>(&box_below_eq); }
+TExecFunc arrow_box_center() { return MakeIndirectExec<true, false>(&box_center); }
+TExecFunc arrow_box_circle() { return MakeIndirectExec<true, false>(&box_circle); }
+TExecFunc arrow_box_contain() { return MakeIndirectExec<true, true>(&box_contain); }
+TExecFunc arrow_box_contain_pt() { return MakeIndirectExec<true, true>(&box_contain_pt); }
+TExecFunc arrow_box_contained() { return MakeIndirectExec<true, true>(&box_contained); }
+TExecFunc arrow_box_diagonal() { return MakeIndirectExec<true, false>(&box_diagonal); }
+TExecFunc arrow_box_distance() { return MakeIndirectExec<true, true>(&box_distance); }
+TExecFunc arrow_box_div() { return MakeIndirectExec<true, false>(&box_div); }
+TExecFunc arrow_box_eq() { return MakeIndirectExec<true, true>(&box_eq); }
+TExecFunc arrow_box_ge() { return MakeIndirectExec<true, true>(&box_ge); }
+TExecFunc arrow_box_gt() { return MakeIndirectExec<true, true>(&box_gt); }
+TExecFunc arrow_box_height() { return MakeIndirectExec<true, true>(&box_height); }
+TExecFunc arrow_box_in() { return MakeIndirectExec<true, false>(&box_in); }
+TExecFunc arrow_box_intersect() { return MakeIndirectExec<true, false>(&box_intersect); }
+TExecFunc arrow_box_le() { return MakeIndirectExec<true, true>(&box_le); }
+TExecFunc arrow_box_left() { return MakeIndirectExec<true, true>(&box_left); }
+TExecFunc arrow_box_lt() { return MakeIndirectExec<true, true>(&box_lt); }
+TExecFunc arrow_box_mul() { return MakeIndirectExec<true, false>(&box_mul); }
+TExecFunc arrow_box_out() { return MakeIndirectExec<true, false>(&box_out); }
+TExecFunc arrow_box_overabove() { return MakeIndirectExec<true, true>(&box_overabove); }
+TExecFunc arrow_box_overbelow() { return MakeIndirectExec<true, true>(&box_overbelow); }
+TExecFunc arrow_box_overlap() { return MakeIndirectExec<true, true>(&box_overlap); }
+TExecFunc arrow_box_overleft() { return MakeIndirectExec<true, true>(&box_overleft); }
+TExecFunc arrow_box_overright() { return MakeIndirectExec<true, true>(&box_overright); }
+TExecFunc arrow_box_poly() { return MakeIndirectExec<true, false>(&box_poly); }
+TExecFunc arrow_box_recv() { return MakeIndirectExec<true, false>(&box_recv); }
+TExecFunc arrow_box_right() { return MakeIndirectExec<true, true>(&box_right); }
+TExecFunc arrow_box_same() { return MakeIndirectExec<true, true>(&box_same); }
+TExecFunc arrow_box_send() { return MakeIndirectExec<true, false>(&box_send); }
+TExecFunc arrow_box_sub() { return MakeIndirectExec<true, false>(&box_sub); }
+TExecFunc arrow_box_width() { return MakeIndirectExec<true, true>(&box_width); }
+TExecFunc arrow_boxes_bound_box() { return MakeIndirectExec<true, false>(&boxes_bound_box); }
+TExecFunc arrow_brin_bloom_add_value() { return MakeIndirectExec<true, true>(&brin_bloom_add_value); }
+TExecFunc arrow_brin_bloom_consistent() { return MakeIndirectExec<true, true>(&brin_bloom_consistent); }
+TExecFunc arrow_brin_bloom_opcinfo() { return MakeIndirectExec<true, true>(&brin_bloom_opcinfo); }
+TExecFunc arrow_brin_bloom_options() { return MakeIndirectExec<false, true>(&brin_bloom_options); }
+TExecFunc arrow_brin_bloom_summary_in() { return MakeIndirectExec<true, false>(&brin_bloom_summary_in); }
+TExecFunc arrow_brin_bloom_summary_out() { return MakeIndirectExec<true, false>(&brin_bloom_summary_out); }
+TExecFunc arrow_brin_bloom_summary_recv() { return MakeIndirectExec<true, false>(&brin_bloom_summary_recv); }
+TExecFunc arrow_brin_bloom_summary_send() { return MakeIndirectExec<true, false>(&brin_bloom_summary_send); }
+TExecFunc arrow_brin_bloom_union() { return MakeIndirectExec<true, true>(&brin_bloom_union); }
+TExecFunc arrow_bttidcmp() { return MakeIndirectExec<true, true>(&bttidcmp); }
+TExecFunc arrow_cash_cmp() { return MakeIndirectExec<true, true>(&cash_cmp); }
+TExecFunc arrow_cash_div_cash() { return MakeIndirectExec<true, true>(&cash_div_cash); }
+TExecFunc arrow_cash_div_flt4() { return MakeIndirectExec<true, true>(&cash_div_flt4); }
+TExecFunc arrow_cash_div_flt8() { return MakeIndirectExec<true, true>(&cash_div_flt8); }
+TExecFunc arrow_cash_div_int2() { return MakeIndirectExec<true, true>(&cash_div_int2); }
+TExecFunc arrow_cash_div_int4() { return MakeIndirectExec<true, true>(&cash_div_int4); }
+TExecFunc arrow_cash_div_int8() { return MakeIndirectExec<true, true>(&cash_div_int8); }
+TExecFunc arrow_cash_eq() { return MakeIndirectExec<true, true>(&cash_eq); }
+TExecFunc arrow_cash_ge() { return MakeIndirectExec<true, true>(&cash_ge); }
+TExecFunc arrow_cash_gt() { return MakeIndirectExec<true, true>(&cash_gt); }
+TExecFunc arrow_cash_in() { return MakeIndirectExec<true, true>(&cash_in); }
+TExecFunc arrow_cash_le() { return MakeIndirectExec<true, true>(&cash_le); }
+TExecFunc arrow_cash_lt() { return MakeIndirectExec<true, true>(&cash_lt); }
+TExecFunc arrow_cash_mi() { return MakeIndirectExec<true, true>(&cash_mi); }
+TExecFunc arrow_cash_mul_flt4() { return MakeIndirectExec<true, true>(&cash_mul_flt4); }
+TExecFunc arrow_cash_mul_flt8() { return MakeIndirectExec<true, true>(&cash_mul_flt8); }
+TExecFunc arrow_cash_mul_int2() { return MakeIndirectExec<true, true>(&cash_mul_int2); }
+TExecFunc arrow_cash_mul_int4() { return MakeIndirectExec<true, true>(&cash_mul_int4); }
+TExecFunc arrow_cash_mul_int8() { return MakeIndirectExec<true, true>(&cash_mul_int8); }
+TExecFunc arrow_cash_ne() { return MakeIndirectExec<true, true>(&cash_ne); }
+TExecFunc arrow_cash_numeric() { return MakeIndirectExec<true, false>(&cash_numeric); }
+TExecFunc arrow_cash_out() { return MakeIndirectExec<true, false>(&cash_out); }
+TExecFunc arrow_cash_pl() { return MakeIndirectExec<true, true>(&cash_pl); }
+TExecFunc arrow_cash_recv() { return MakeIndirectExec<true, true>(&cash_recv); }
+TExecFunc arrow_cash_send() { return MakeIndirectExec<true, false>(&cash_send); }
+TExecFunc arrow_cash_words() { return MakeIndirectExec<true, false>(&cash_words); }
+TExecFunc arrow_cashlarger() { return MakeIndirectExec<true, true>(&cashlarger); }
+TExecFunc arrow_cashsmaller() { return MakeIndirectExec<true, true>(&cashsmaller); }
+TExecFunc arrow_circle_above() { return MakeIndirectExec<true, true>(&circle_above); }
+TExecFunc arrow_circle_add_pt() { return MakeIndirectExec<true, false>(&circle_add_pt); }
+TExecFunc arrow_circle_area() { return MakeIndirectExec<true, true>(&circle_area); }
+TExecFunc arrow_circle_below() { return MakeIndirectExec<true, true>(&circle_below); }
+TExecFunc arrow_circle_box() { return MakeIndirectExec<true, false>(&circle_box); }
+TExecFunc arrow_circle_center() { return MakeIndirectExec<true, false>(&circle_center); }
+TExecFunc arrow_circle_contain() { return MakeIndirectExec<true, true>(&circle_contain); }
+TExecFunc arrow_circle_contain_pt() { return MakeIndirectExec<true, true>(&circle_contain_pt); }
+TExecFunc arrow_circle_contained() { return MakeIndirectExec<true, true>(&circle_contained); }
+TExecFunc arrow_circle_diameter() { return MakeIndirectExec<true, true>(&circle_diameter); }
+TExecFunc arrow_circle_distance() { return MakeIndirectExec<true, true>(&circle_distance); }
+TExecFunc arrow_circle_div_pt() { return MakeIndirectExec<true, false>(&circle_div_pt); }
+TExecFunc arrow_circle_eq() { return MakeIndirectExec<true, true>(&circle_eq); }
+TExecFunc arrow_circle_ge() { return MakeIndirectExec<true, true>(&circle_ge); }
+TExecFunc arrow_circle_gt() { return MakeIndirectExec<true, true>(&circle_gt); }
+TExecFunc arrow_circle_in() { return MakeIndirectExec<true, false>(&circle_in); }
+TExecFunc arrow_circle_le() { return MakeIndirectExec<true, true>(&circle_le); }
+TExecFunc arrow_circle_left() { return MakeIndirectExec<true, true>(&circle_left); }
+TExecFunc arrow_circle_lt() { return MakeIndirectExec<true, true>(&circle_lt); }
+TExecFunc arrow_circle_mul_pt() { return MakeIndirectExec<true, false>(&circle_mul_pt); }
+TExecFunc arrow_circle_ne() { return MakeIndirectExec<true, true>(&circle_ne); }
+TExecFunc arrow_circle_out() { return MakeIndirectExec<true, false>(&circle_out); }
+TExecFunc arrow_circle_overabove() { return MakeIndirectExec<true, true>(&circle_overabove); }
+TExecFunc arrow_circle_overbelow() { return MakeIndirectExec<true, true>(&circle_overbelow); }
+TExecFunc arrow_circle_overlap() { return MakeIndirectExec<true, true>(&circle_overlap); }
+TExecFunc arrow_circle_overleft() { return MakeIndirectExec<true, true>(&circle_overleft); }
+TExecFunc arrow_circle_overright() { return MakeIndirectExec<true, true>(&circle_overright); }
+TExecFunc arrow_circle_poly() { return MakeIndirectExec<true, false>(&circle_poly); }
+TExecFunc arrow_circle_radius() { return MakeIndirectExec<true, true>(&circle_radius); }
+TExecFunc arrow_circle_recv() { return MakeIndirectExec<true, false>(&circle_recv); }
+TExecFunc arrow_circle_right() { return MakeIndirectExec<true, true>(&circle_right); }
+TExecFunc arrow_circle_same() { return MakeIndirectExec<true, true>(&circle_same); }
+TExecFunc arrow_circle_send() { return MakeIndirectExec<true, false>(&circle_send); }
+TExecFunc arrow_circle_sub_pt() { return MakeIndirectExec<true, false>(&circle_sub_pt); }
+TExecFunc arrow_clock_timestamp() { return MakeIndirectExec<true, true>(&clock_timestamp); }
+TExecFunc arrow_close_lb() { return MakeIndirectExec<true, false>(&close_lb); }
+TExecFunc arrow_close_ls() { return MakeIndirectExec<true, false>(&close_ls); }
+TExecFunc arrow_close_lseg() { return MakeIndirectExec<true, false>(&close_lseg); }
+TExecFunc arrow_close_pb() { return MakeIndirectExec<true, false>(&close_pb); }
+TExecFunc arrow_close_pl() { return MakeIndirectExec<true, false>(&close_pl); }
+TExecFunc arrow_close_ps() { return MakeIndirectExec<true, false>(&close_ps); }
+TExecFunc arrow_close_sb() { return MakeIndirectExec<true, false>(&close_sb); }
+TExecFunc arrow_close_sl() { return MakeIndirectExec<true, false>(&close_sl); }
+TExecFunc arrow_construct_point() { return MakeIndirectExec<true, false>(&construct_point); }
+TExecFunc arrow_contjoinsel() { return MakeIndirectExec<true, true>(&contjoinsel); }
+TExecFunc arrow_contsel() { return MakeIndirectExec<true, true>(&contsel); }
+TExecFunc arrow_cr_circle() { return MakeIndirectExec<true, false>(&cr_circle); }
+TExecFunc arrow_current_database() { return MakeIndirectExec<true, false>(&current_database); }
+TExecFunc arrow_current_query() { return MakeIndirectExec<false, false>(&current_query); }
+TExecFunc arrow_currtid_byrelname() { return MakeIndirectExec<true, false>(&currtid_byrelname); }
+TExecFunc arrow_dist_bl() { return MakeIndirectExec<true, true>(&dist_bl); }
+TExecFunc arrow_dist_bp() { return MakeIndirectExec<true, true>(&dist_bp); }
+TExecFunc arrow_dist_bs() { return MakeIndirectExec<true, true>(&dist_bs); }
+TExecFunc arrow_dist_cpoint() { return MakeIndirectExec<true, true>(&dist_cpoint); }
+TExecFunc arrow_dist_cpoly() { return MakeIndirectExec<true, true>(&dist_cpoly); }
+TExecFunc arrow_dist_lb() { return MakeIndirectExec<true, true>(&dist_lb); }
+TExecFunc arrow_dist_lp() { return MakeIndirectExec<true, true>(&dist_lp); }
+TExecFunc arrow_dist_ls() { return MakeIndirectExec<true, true>(&dist_ls); }
+TExecFunc arrow_dist_pathp() { return MakeIndirectExec<true, true>(&dist_pathp); }
+TExecFunc arrow_dist_pb() { return MakeIndirectExec<true, true>(&dist_pb); }
+TExecFunc arrow_dist_pc() { return MakeIndirectExec<true, true>(&dist_pc); }
+TExecFunc arrow_dist_pl() { return MakeIndirectExec<true, true>(&dist_pl); }
+TExecFunc arrow_dist_polyc() { return MakeIndirectExec<true, true>(&dist_polyc); }
+TExecFunc arrow_dist_polyp() { return MakeIndirectExec<true, true>(&dist_polyp); }
+TExecFunc arrow_dist_ppath() { return MakeIndirectExec<true, true>(&dist_ppath); }
+TExecFunc arrow_dist_ppoly() { return MakeIndirectExec<true, true>(&dist_ppoly); }
+TExecFunc arrow_dist_ps() { return MakeIndirectExec<true, true>(&dist_ps); }
+TExecFunc arrow_dist_sb() { return MakeIndirectExec<true, true>(&dist_sb); }
+TExecFunc arrow_dist_sl() { return MakeIndirectExec<true, true>(&dist_sl); }
+TExecFunc arrow_dist_sp() { return MakeIndirectExec<true, true>(&dist_sp); }
+TExecFunc arrow_extract_interval() { return MakeIndirectExec<true, false>(&extract_interval); }
+TExecFunc arrow_extract_timestamp() { return MakeIndirectExec<true, false>(&extract_timestamp); }
+TExecFunc arrow_extract_timestamptz() { return MakeIndirectExec<true, false>(&extract_timestamptz); }
+TExecFunc arrow_float4_numeric() { return MakeIndirectExec<true, false>(&float4_numeric); }
+TExecFunc arrow_float4_to_char() { return MakeIndirectExec<true, false>(&float4_to_char); }
+TExecFunc arrow_float8_numeric() { return MakeIndirectExec<true, false>(&float8_numeric); }
+TExecFunc arrow_float8_timestamptz() { return MakeIndirectExec<true, true>(&float8_timestamptz); }
+TExecFunc arrow_float8_to_char() { return MakeIndirectExec<true, false>(&float8_to_char); }
+TExecFunc arrow_flt4_mul_cash() { return MakeIndirectExec<true, true>(&flt4_mul_cash); }
+TExecFunc arrow_flt8_mul_cash() { return MakeIndirectExec<true, true>(&flt8_mul_cash); }
+TExecFunc arrow_ginarrayconsistent() { return MakeIndirectExec<true, true>(&ginarrayconsistent); }
+TExecFunc arrow_ginarrayextract() { return MakeIndirectExec<true, true>(&ginarrayextract); }
+TExecFunc arrow_ginarrayextract_2args() { return MakeIndirectExec<true, true>(&ginarrayextract_2args); }
+TExecFunc arrow_ginarraytriconsistent() { return MakeIndirectExec<true, true>(&ginarraytriconsistent); }
+TExecFunc arrow_ginqueryarrayextract() { return MakeIndirectExec<true, true>(&ginqueryarrayextract); }
+TExecFunc arrow_hash_numeric() { return MakeIndirectExec<true, true>(&hash_numeric); }
+TExecFunc arrow_hash_numeric_extended() { return MakeIndirectExec<true, true>(&hash_numeric_extended); }
+TExecFunc arrow_hashtid() { return MakeIndirectExec<true, true>(&hashtid); }
+TExecFunc arrow_hashtidextended() { return MakeIndirectExec<true, true>(&hashtidextended); }
+TExecFunc arrow_iclikejoinsel() { return MakeIndirectExec<true, true>(&iclikejoinsel); }
+TExecFunc arrow_iclikesel() { return MakeIndirectExec<true, true>(&iclikesel); }
+TExecFunc arrow_icnlikejoinsel() { return MakeIndirectExec<true, true>(&icnlikejoinsel); }
+TExecFunc arrow_icnlikesel() { return MakeIndirectExec<true, true>(&icnlikesel); }
+TExecFunc arrow_icregexeqjoinsel() { return MakeIndirectExec<true, true>(&icregexeqjoinsel); }
+TExecFunc arrow_icregexeqsel() { return MakeIndirectExec<true, true>(&icregexeqsel); }
+TExecFunc arrow_icregexnejoinsel() { return MakeIndirectExec<true, true>(&icregexnejoinsel); }
+TExecFunc arrow_icregexnesel() { return MakeIndirectExec<true, true>(&icregexnesel); }
+TExecFunc arrow_in_range_interval_interval() { return MakeIndirectExec<true, true>(&in_range_interval_interval); }
+TExecFunc arrow_in_range_numeric_numeric() { return MakeIndirectExec<true, true>(&in_range_numeric_numeric); }
+TExecFunc arrow_in_range_timestamp_interval() { return MakeIndirectExec<true, true>(&in_range_timestamp_interval); }
+TExecFunc arrow_in_range_timestamptz_interval() { return MakeIndirectExec<true, true>(&in_range_timestamptz_interval); }
+TExecFunc arrow_inet_gist_compress() { return MakeIndirectExec<true, true>(&inet_gist_compress); }
+TExecFunc arrow_inet_gist_consistent() { return MakeIndirectExec<true, true>(&inet_gist_consistent); }
+TExecFunc arrow_inet_gist_fetch() { return MakeIndirectExec<true, true>(&inet_gist_fetch); }
+TExecFunc arrow_inet_gist_penalty() { return MakeIndirectExec<true, true>(&inet_gist_penalty); }
+TExecFunc arrow_inet_gist_picksplit() { return MakeIndirectExec<true, true>(&inet_gist_picksplit); }
+TExecFunc arrow_inet_gist_same() { return MakeIndirectExec<true, true>(&inet_gist_same); }
+TExecFunc arrow_inet_gist_union() { return MakeIndirectExec<true, false>(&inet_gist_union); }
+TExecFunc arrow_int2_accum() { return MakeIndirectExec<false, true>(&int2_accum); }
+TExecFunc arrow_int2_accum_inv() { return MakeIndirectExec<false, true>(&int2_accum_inv); }
+TExecFunc arrow_int2_avg_accum() { return MakeIndirectExec<true, false>(&int2_avg_accum); }
+TExecFunc arrow_int2_avg_accum_inv() { return MakeIndirectExec<true, false>(&int2_avg_accum_inv); }
+TExecFunc arrow_int2_mul_cash() { return MakeIndirectExec<true, true>(&int2_mul_cash); }
+TExecFunc arrow_int2_numeric() { return MakeIndirectExec<true, false>(&int2_numeric); }
+TExecFunc arrow_int2_sum() { return MakeIndirectExec<false, true>(&int2_sum); }
+TExecFunc arrow_int2int4_sum() { return MakeIndirectExec<true, true>(&int2int4_sum); }
+TExecFunc arrow_int4_accum() { return MakeIndirectExec<false, true>(&int4_accum); }
+TExecFunc arrow_int4_accum_inv() { return MakeIndirectExec<false, true>(&int4_accum_inv); }
+TExecFunc arrow_int4_avg_accum() { return MakeIndirectExec<true, false>(&int4_avg_accum); }
+TExecFunc arrow_int4_avg_accum_inv() { return MakeIndirectExec<true, false>(&int4_avg_accum_inv); }
+TExecFunc arrow_int4_avg_combine() { return MakeIndirectExec<true, false>(&int4_avg_combine); }
+TExecFunc arrow_int4_cash() { return MakeIndirectExec<true, true>(&int4_cash); }
+TExecFunc arrow_int4_mul_cash() { return MakeIndirectExec<true, true>(&int4_mul_cash); }
+TExecFunc arrow_int4_numeric() { return MakeIndirectExec<true, false>(&int4_numeric); }
+TExecFunc arrow_int4_sum() { return MakeIndirectExec<false, true>(&int4_sum); }
+TExecFunc arrow_int4_to_char() { return MakeIndirectExec<true, false>(&int4_to_char); }
+TExecFunc arrow_int8_accum() { return MakeIndirectExec<false, true>(&int8_accum); }
+TExecFunc arrow_int8_accum_inv() { return MakeIndirectExec<false, true>(&int8_accum_inv); }
+TExecFunc arrow_int8_avg() { return MakeIndirectExec<true, false>(&int8_avg); }
+TExecFunc arrow_int8_avg_accum() { return MakeIndirectExec<false, true>(&int8_avg_accum); }
+TExecFunc arrow_int8_avg_accum_inv() { return MakeIndirectExec<false, true>(&int8_avg_accum_inv); }
+TExecFunc arrow_int8_avg_combine() { return MakeIndirectExec<false, true>(&int8_avg_combine); }
+TExecFunc arrow_int8_avg_deserialize() { return MakeIndirectExec<true, true>(&int8_avg_deserialize); }
+TExecFunc arrow_int8_avg_serialize() { return MakeIndirectExec<true, false>(&int8_avg_serialize); }
+TExecFunc arrow_int8_cash() { return MakeIndirectExec<true, true>(&int8_cash); }
+TExecFunc arrow_int8_mul_cash() { return MakeIndirectExec<true, true>(&int8_mul_cash); }
+TExecFunc arrow_int8_numeric() { return MakeIndirectExec<true, false>(&int8_numeric); }
+TExecFunc arrow_int8_sum() { return MakeIndirectExec<false, false>(&int8_sum); }
+TExecFunc arrow_int8_to_char() { return MakeIndirectExec<true, false>(&int8_to_char); }
+TExecFunc arrow_inter_lb() { return MakeIndirectExec<true, true>(&inter_lb); }
+TExecFunc arrow_inter_sb() { return MakeIndirectExec<true, true>(&inter_sb); }
+TExecFunc arrow_inter_sl() { return MakeIndirectExec<true, true>(&inter_sl); }
+TExecFunc arrow_interval_accum() { return MakeIndirectExec<true, false>(&interval_accum); }
+TExecFunc arrow_interval_accum_inv() { return MakeIndirectExec<true, false>(&interval_accum_inv); }
+TExecFunc arrow_interval_avg() { return MakeIndirectExec<true, false>(&interval_avg); }
+TExecFunc arrow_interval_cmp() { return MakeIndirectExec<true, true>(&interval_cmp); }
+TExecFunc arrow_interval_combine() { return MakeIndirectExec<true, false>(&interval_combine); }
+TExecFunc arrow_interval_div() { return MakeIndirectExec<true, false>(&interval_div); }
+TExecFunc arrow_interval_eq() { return MakeIndirectExec<true, true>(&interval_eq); }
+TExecFunc arrow_interval_finite() { return MakeIndirectExec<true, true>(&interval_finite); }
+TExecFunc arrow_interval_ge() { return MakeIndirectExec<true, true>(&interval_ge); }
+TExecFunc arrow_interval_gt() { return MakeIndirectExec<true, true>(&interval_gt); }
+TExecFunc arrow_interval_hash() { return MakeIndirectExec<true, true>(&interval_hash); }
+TExecFunc arrow_interval_hash_extended() { return MakeIndirectExec<true, true>(&interval_hash_extended); }
+TExecFunc arrow_interval_in() { return MakeIndirectExec<true, false>(&interval_in); }
+TExecFunc arrow_interval_justify_days() { return MakeIndirectExec<true, false>(&interval_justify_days); }
+TExecFunc arrow_interval_justify_hours() { return MakeIndirectExec<true, false>(&interval_justify_hours); }
+TExecFunc arrow_interval_justify_interval() { return MakeIndirectExec<true, false>(&interval_justify_interval); }
+TExecFunc arrow_interval_larger() { return MakeIndirectExec<true, false>(&interval_larger); }
+TExecFunc arrow_interval_le() { return MakeIndirectExec<true, true>(&interval_le); }
+TExecFunc arrow_interval_lt() { return MakeIndirectExec<true, true>(&interval_lt); }
+TExecFunc arrow_interval_mi() { return MakeIndirectExec<true, false>(&interval_mi); }
+TExecFunc arrow_interval_mul() { return MakeIndirectExec<true, false>(&interval_mul); }
+TExecFunc arrow_interval_ne() { return MakeIndirectExec<true, true>(&interval_ne); }
+TExecFunc arrow_interval_out() { return MakeIndirectExec<true, false>(&interval_out); }
+TExecFunc arrow_interval_part() { return MakeIndirectExec<true, true>(&interval_part); }
+TExecFunc arrow_interval_pl() { return MakeIndirectExec<true, false>(&interval_pl); }
+TExecFunc arrow_interval_recv() { return MakeIndirectExec<true, false>(&interval_recv); }
+TExecFunc arrow_interval_scale() { return MakeIndirectExec<true, false>(&interval_scale); }
+TExecFunc arrow_interval_send() { return MakeIndirectExec<true, false>(&interval_send); }
+TExecFunc arrow_interval_smaller() { return MakeIndirectExec<true, false>(&interval_smaller); }
+TExecFunc arrow_interval_support() { return MakeIndirectExec<true, true>(&interval_support); }
+TExecFunc arrow_interval_to_char() { return MakeIndirectExec<true, false>(&interval_to_char); }
+TExecFunc arrow_interval_trunc() { return MakeIndirectExec<true, false>(&interval_trunc); }
+TExecFunc arrow_interval_um() { return MakeIndirectExec<true, false>(&interval_um); }
+TExecFunc arrow_intervaltypmodin() { return MakeIndirectExec<true, true>(&intervaltypmodin); }
+TExecFunc arrow_intervaltypmodout() { return MakeIndirectExec<true, false>(&intervaltypmodout); }
+TExecFunc arrow_likejoinsel() { return MakeIndirectExec<true, true>(&likejoinsel); }
+TExecFunc arrow_likesel() { return MakeIndirectExec<true, true>(&likesel); }
+TExecFunc arrow_line_construct_pp() { return MakeIndirectExec<true, false>(&line_construct_pp); }
+TExecFunc arrow_line_distance() { return MakeIndirectExec<true, true>(&line_distance); }
+TExecFunc arrow_line_eq() { return MakeIndirectExec<true, true>(&line_eq); }
+TExecFunc arrow_line_horizontal() { return MakeIndirectExec<true, true>(&line_horizontal); }
+TExecFunc arrow_line_in() { return MakeIndirectExec<true, false>(&line_in); }
+TExecFunc arrow_line_interpt() { return MakeIndirectExec<true, false>(&line_interpt); }
+TExecFunc arrow_line_intersect() { return MakeIndirectExec<true, true>(&line_intersect); }
+TExecFunc arrow_line_out() { return MakeIndirectExec<true, false>(&line_out); }
+TExecFunc arrow_line_parallel() { return MakeIndirectExec<true, true>(&line_parallel); }
+TExecFunc arrow_line_perp() { return MakeIndirectExec<true, true>(&line_perp); }
+TExecFunc arrow_line_recv() { return MakeIndirectExec<true, false>(&line_recv); }
+TExecFunc arrow_line_send() { return MakeIndirectExec<true, false>(&line_send); }
+TExecFunc arrow_line_vertical() { return MakeIndirectExec<true, true>(&line_vertical); }
+TExecFunc arrow_lseg_center() { return MakeIndirectExec<true, false>(&lseg_center); }
+TExecFunc arrow_lseg_construct() { return MakeIndirectExec<true, false>(&lseg_construct); }
+TExecFunc arrow_lseg_distance() { return MakeIndirectExec<true, true>(&lseg_distance); }
+TExecFunc arrow_lseg_eq() { return MakeIndirectExec<true, true>(&lseg_eq); }
+TExecFunc arrow_lseg_ge() { return MakeIndirectExec<true, true>(&lseg_ge); }
+TExecFunc arrow_lseg_gt() { return MakeIndirectExec<true, true>(&lseg_gt); }
+TExecFunc arrow_lseg_horizontal() { return MakeIndirectExec<true, true>(&lseg_horizontal); }
+TExecFunc arrow_lseg_in() { return MakeIndirectExec<true, false>(&lseg_in); }
+TExecFunc arrow_lseg_interpt() { return MakeIndirectExec<true, false>(&lseg_interpt); }
+TExecFunc arrow_lseg_intersect() { return MakeIndirectExec<true, true>(&lseg_intersect); }
+TExecFunc arrow_lseg_le() { return MakeIndirectExec<true, true>(&lseg_le); }
+TExecFunc arrow_lseg_length() { return MakeIndirectExec<true, true>(&lseg_length); }
+TExecFunc arrow_lseg_lt() { return MakeIndirectExec<true, true>(&lseg_lt); }
+TExecFunc arrow_lseg_ne() { return MakeIndirectExec<true, true>(&lseg_ne); }
+TExecFunc arrow_lseg_out() { return MakeIndirectExec<true, false>(&lseg_out); }
+TExecFunc arrow_lseg_parallel() { return MakeIndirectExec<true, true>(&lseg_parallel); }
+TExecFunc arrow_lseg_perp() { return MakeIndirectExec<true, true>(&lseg_perp); }
+TExecFunc arrow_lseg_recv() { return MakeIndirectExec<true, false>(&lseg_recv); }
+TExecFunc arrow_lseg_send() { return MakeIndirectExec<true, false>(&lseg_send); }
+TExecFunc arrow_lseg_vertical() { return MakeIndirectExec<true, true>(&lseg_vertical); }
+TExecFunc arrow_make_interval() { return MakeIndirectExec<true, false>(&make_interval); }
+TExecFunc arrow_make_timestamp() { return MakeIndirectExec<true, true>(&make_timestamp); }
+TExecFunc arrow_make_timestamptz() { return MakeIndirectExec<true, true>(&make_timestamptz); }
+TExecFunc arrow_make_timestamptz_at_timezone() { return MakeIndirectExec<true, true>(&make_timestamptz_at_timezone); }
+TExecFunc arrow_md5_bytea() { return MakeIndirectExec<true, false>(&md5_bytea); }
+TExecFunc arrow_md5_text() { return MakeIndirectExec<true, false>(&md5_text); }
+TExecFunc arrow_mul_d_interval() { return MakeIndirectExec<true, false>(&mul_d_interval); }
+TExecFunc arrow_nlikejoinsel() { return MakeIndirectExec<true, true>(&nlikejoinsel); }
+TExecFunc arrow_nlikesel() { return MakeIndirectExec<true, true>(&nlikesel); }
+TExecFunc arrow_now() { return MakeIndirectExec<true, true>(&now); }
+TExecFunc arrow_numeric() { return MakeIndirectExec<true, false>(&numeric); }
+TExecFunc arrow_numeric_abs() { return MakeIndirectExec<true, false>(&numeric_abs); }
+TExecFunc arrow_numeric_accum() { return MakeIndirectExec<false, true>(&numeric_accum); }
+TExecFunc arrow_numeric_accum_inv() { return MakeIndirectExec<false, true>(&numeric_accum_inv); }
+TExecFunc arrow_numeric_add() { return MakeIndirectExec<true, false>(&numeric_add); }
+TExecFunc arrow_numeric_avg() { return MakeIndirectExec<false, false>(&numeric_avg); }
+TExecFunc arrow_numeric_avg_accum() { return MakeIndirectExec<false, true>(&numeric_avg_accum); }
+TExecFunc arrow_numeric_avg_combine() { return MakeIndirectExec<false, true>(&numeric_avg_combine); }
+TExecFunc arrow_numeric_avg_deserialize() { return MakeIndirectExec<true, true>(&numeric_avg_deserialize); }
+TExecFunc arrow_numeric_avg_serialize() { return MakeIndirectExec<true, false>(&numeric_avg_serialize); }
+TExecFunc arrow_numeric_cash() { return MakeIndirectExec<true, true>(&numeric_cash); }
+TExecFunc arrow_numeric_ceil() { return MakeIndirectExec<true, false>(&numeric_ceil); }
+TExecFunc arrow_numeric_cmp() { return MakeIndirectExec<true, true>(&numeric_cmp); }
+TExecFunc arrow_numeric_combine() { return MakeIndirectExec<false, true>(&numeric_combine); }
+TExecFunc arrow_numeric_deserialize() { return MakeIndirectExec<true, true>(&numeric_deserialize); }
+TExecFunc arrow_numeric_div() { return MakeIndirectExec<true, false>(&numeric_div); }
+TExecFunc arrow_numeric_div_trunc() { return MakeIndirectExec<true, false>(&numeric_div_trunc); }
+TExecFunc arrow_numeric_eq() { return MakeIndirectExec<true, true>(&numeric_eq); }
+TExecFunc arrow_numeric_exp() { return MakeIndirectExec<true, false>(&numeric_exp); }
+TExecFunc arrow_numeric_fac() { return MakeIndirectExec<true, false>(&numeric_fac); }
+TExecFunc arrow_numeric_float4() { return MakeIndirectExec<true, true>(&numeric_float4); }
+TExecFunc arrow_numeric_float8() { return MakeIndirectExec<true, true>(&numeric_float8); }
+TExecFunc arrow_numeric_floor() { return MakeIndirectExec<true, false>(&numeric_floor); }
+TExecFunc arrow_numeric_gcd() { return MakeIndirectExec<true, false>(&numeric_gcd); }
+TExecFunc arrow_numeric_ge() { return MakeIndirectExec<true, true>(&numeric_ge); }
+TExecFunc arrow_numeric_gt() { return MakeIndirectExec<true, true>(&numeric_gt); }
+TExecFunc arrow_numeric_in() { return MakeIndirectExec<true, false>(&numeric_in); }
+TExecFunc arrow_numeric_inc() { return MakeIndirectExec<true, false>(&numeric_inc); }
+TExecFunc arrow_numeric_int2() { return MakeIndirectExec<true, true>(&numeric_int2); }
+TExecFunc arrow_numeric_int4() { return MakeIndirectExec<true, true>(&numeric_int4); }
+TExecFunc arrow_numeric_int8() { return MakeIndirectExec<true, true>(&numeric_int8); }
+TExecFunc arrow_numeric_larger() { return MakeIndirectExec<true, false>(&numeric_larger); }
+TExecFunc arrow_numeric_lcm() { return MakeIndirectExec<true, false>(&numeric_lcm); }
+TExecFunc arrow_numeric_le() { return MakeIndirectExec<true, true>(&numeric_le); }
+TExecFunc arrow_numeric_ln() { return MakeIndirectExec<true, false>(&numeric_ln); }
+TExecFunc arrow_numeric_log() { return MakeIndirectExec<true, false>(&numeric_log); }
+TExecFunc arrow_numeric_lt() { return MakeIndirectExec<true, true>(&numeric_lt); }
+TExecFunc arrow_numeric_min_scale() { return MakeIndirectExec<true, true>(&numeric_min_scale); }
+TExecFunc arrow_numeric_mod() { return MakeIndirectExec<true, false>(&numeric_mod); }
+TExecFunc arrow_numeric_mul() { return MakeIndirectExec<true, false>(&numeric_mul); }
+TExecFunc arrow_numeric_ne() { return MakeIndirectExec<true, true>(&numeric_ne); }
+TExecFunc arrow_numeric_out() { return MakeIndirectExec<true, false>(&numeric_out); }
+TExecFunc arrow_numeric_pg_lsn() { return MakeIndirectExec<true, true>(&numeric_pg_lsn); }
+TExecFunc arrow_numeric_poly_avg() { return MakeIndirectExec<false, false>(&numeric_poly_avg); }
+TExecFunc arrow_numeric_poly_combine() { return MakeIndirectExec<false, true>(&numeric_poly_combine); }
+TExecFunc arrow_numeric_poly_deserialize() { return MakeIndirectExec<true, true>(&numeric_poly_deserialize); }
+TExecFunc arrow_numeric_poly_serialize() { return MakeIndirectExec<true, false>(&numeric_poly_serialize); }
+TExecFunc arrow_numeric_poly_stddev_pop() { return MakeIndirectExec<false, false>(&numeric_poly_stddev_pop); }
+TExecFunc arrow_numeric_poly_stddev_samp() { return MakeIndirectExec<false, false>(&numeric_poly_stddev_samp); }
+TExecFunc arrow_numeric_poly_sum() { return MakeIndirectExec<false, false>(&numeric_poly_sum); }
+TExecFunc arrow_numeric_poly_var_pop() { return MakeIndirectExec<false, false>(&numeric_poly_var_pop); }
+TExecFunc arrow_numeric_poly_var_samp() { return MakeIndirectExec<false, false>(&numeric_poly_var_samp); }
+TExecFunc arrow_numeric_power() { return MakeIndirectExec<true, false>(&numeric_power); }
+TExecFunc arrow_numeric_recv() { return MakeIndirectExec<true, false>(&numeric_recv); }
+TExecFunc arrow_numeric_round() { return MakeIndirectExec<true, false>(&numeric_round); }
+TExecFunc arrow_numeric_scale() { return MakeIndirectExec<true, true>(&numeric_scale); }
+TExecFunc arrow_numeric_send() { return MakeIndirectExec<true, false>(&numeric_send); }
+TExecFunc arrow_numeric_serialize() { return MakeIndirectExec<true, false>(&numeric_serialize); }
+TExecFunc arrow_numeric_sign() { return MakeIndirectExec<true, false>(&numeric_sign); }
+TExecFunc arrow_numeric_smaller() { return MakeIndirectExec<true, false>(&numeric_smaller); }
+TExecFunc arrow_numeric_sortsupport() { return MakeIndirectExec<true, true>(&numeric_sortsupport); }
+TExecFunc arrow_numeric_sqrt() { return MakeIndirectExec<true, false>(&numeric_sqrt); }
+TExecFunc arrow_numeric_stddev_pop() { return MakeIndirectExec<false, false>(&numeric_stddev_pop); }
+TExecFunc arrow_numeric_stddev_samp() { return MakeIndirectExec<false, false>(&numeric_stddev_samp); }
+TExecFunc arrow_numeric_sub() { return MakeIndirectExec<true, false>(&numeric_sub); }
+TExecFunc arrow_numeric_sum() { return MakeIndirectExec<false, false>(&numeric_sum); }
+TExecFunc arrow_numeric_support() { return MakeIndirectExec<true, true>(&numeric_support); }
+TExecFunc arrow_numeric_to_char() { return MakeIndirectExec<true, false>(&numeric_to_char); }
+TExecFunc arrow_numeric_to_number() { return MakeIndirectExec<true, false>(&numeric_to_number); }
+TExecFunc arrow_numeric_trim_scale() { return MakeIndirectExec<true, false>(&numeric_trim_scale); }
+TExecFunc arrow_numeric_trunc() { return MakeIndirectExec<true, false>(&numeric_trunc); }
+TExecFunc arrow_numeric_uminus() { return MakeIndirectExec<true, false>(&numeric_uminus); }
+TExecFunc arrow_numeric_uplus() { return MakeIndirectExec<true, false>(&numeric_uplus); }
+TExecFunc arrow_numeric_var_pop() { return MakeIndirectExec<false, false>(&numeric_var_pop); }
+TExecFunc arrow_numeric_var_samp() { return MakeIndirectExec<false, false>(&numeric_var_samp); }
+TExecFunc arrow_numerictypmodin() { return MakeIndirectExec<true, true>(&numerictypmodin); }
+TExecFunc arrow_numerictypmodout() { return MakeIndirectExec<true, false>(&numerictypmodout); }
+TExecFunc arrow_on_pb() { return MakeIndirectExec<true, true>(&on_pb); }
+TExecFunc arrow_on_pl() { return MakeIndirectExec<true, true>(&on_pl); }
+TExecFunc arrow_on_ppath() { return MakeIndirectExec<true, true>(&on_ppath); }
+TExecFunc arrow_on_ps() { return MakeIndirectExec<true, true>(&on_ps); }
+TExecFunc arrow_on_sb() { return MakeIndirectExec<true, true>(&on_sb); }
+TExecFunc arrow_on_sl() { return MakeIndirectExec<true, true>(&on_sl); }
+TExecFunc arrow_overlaps_timestamp() { return MakeIndirectExec<false, true>(&overlaps_timestamp); }
+TExecFunc arrow_parse_ident() { return MakeIndirectExec<true, false>(&parse_ident); }
+TExecFunc arrow_path_add() { return MakeIndirectExec<true, false>(&path_add); }
+TExecFunc arrow_path_add_pt() { return MakeIndirectExec<true, false>(&path_add_pt); }
+TExecFunc arrow_path_area() { return MakeIndirectExec<true, true>(&path_area); }
+TExecFunc arrow_path_center() { return MakeIndirectExec<true, false>(&path_center); }
+TExecFunc arrow_path_close() { return MakeIndirectExec<true, false>(&path_close); }
+TExecFunc arrow_path_distance() { return MakeIndirectExec<true, true>(&path_distance); }
+TExecFunc arrow_path_div_pt() { return MakeIndirectExec<true, false>(&path_div_pt); }
+TExecFunc arrow_path_in() { return MakeIndirectExec<true, false>(&path_in); }
+TExecFunc arrow_path_inter() { return MakeIndirectExec<true, true>(&path_inter); }
+TExecFunc arrow_path_isclosed() { return MakeIndirectExec<true, true>(&path_isclosed); }
+TExecFunc arrow_path_isopen() { return MakeIndirectExec<true, true>(&path_isopen); }
+TExecFunc arrow_path_length() { return MakeIndirectExec<true, true>(&path_length); }
+TExecFunc arrow_path_mul_pt() { return MakeIndirectExec<true, false>(&path_mul_pt); }
+TExecFunc arrow_path_n_eq() { return MakeIndirectExec<true, true>(&path_n_eq); }
+TExecFunc arrow_path_n_ge() { return MakeIndirectExec<true, true>(&path_n_ge); }
+TExecFunc arrow_path_n_gt() { return MakeIndirectExec<true, true>(&path_n_gt); }
+TExecFunc arrow_path_n_le() { return MakeIndirectExec<true, true>(&path_n_le); }
+TExecFunc arrow_path_n_lt() { return MakeIndirectExec<true, true>(&path_n_lt); }
+TExecFunc arrow_path_npoints() { return MakeIndirectExec<true, true>(&path_npoints); }
+TExecFunc arrow_path_open() { return MakeIndirectExec<true, false>(&path_open); }
+TExecFunc arrow_path_out() { return MakeIndirectExec<true, false>(&path_out); }
+TExecFunc arrow_path_poly() { return MakeIndirectExec<true, false>(&path_poly); }
+TExecFunc arrow_path_recv() { return MakeIndirectExec<true, false>(&path_recv); }
+TExecFunc arrow_path_send() { return MakeIndirectExec<true, false>(&path_send); }
+TExecFunc arrow_path_sub_pt() { return MakeIndirectExec<true, false>(&path_sub_pt); }
+TExecFunc arrow_pg_collation_for() { return MakeIndirectExec<false, false>(&pg_collation_for); }
+TExecFunc arrow_pg_column_is_updatable() { return MakeIndirectExec<true, true>(&pg_column_is_updatable); }
+TExecFunc arrow_pg_conf_load_time() { return MakeIndirectExec<true, true>(&pg_conf_load_time); }
+TExecFunc arrow_pg_copy_logical_replication_slot_a() { return MakeIndirectExec<true, false>(&pg_copy_logical_replication_slot_a); }
+TExecFunc arrow_pg_copy_logical_replication_slot_b() { return MakeIndirectExec<true, false>(&pg_copy_logical_replication_slot_b); }
+TExecFunc arrow_pg_copy_logical_replication_slot_c() { return MakeIndirectExec<true, false>(&pg_copy_logical_replication_slot_c); }
+TExecFunc arrow_pg_copy_physical_replication_slot_a() { return MakeIndirectExec<true, false>(&pg_copy_physical_replication_slot_a); }
+TExecFunc arrow_pg_copy_physical_replication_slot_b() { return MakeIndirectExec<true, false>(&pg_copy_physical_replication_slot_b); }
+TExecFunc arrow_pg_create_logical_replication_slot() { return MakeIndirectExec<true, false>(&pg_create_logical_replication_slot); }
+TExecFunc arrow_pg_create_physical_replication_slot() { return MakeIndirectExec<true, false>(&pg_create_physical_replication_slot); }
+TExecFunc arrow_pg_current_logfile() { return MakeIndirectExec<false, false>(&pg_current_logfile); }
+TExecFunc arrow_pg_current_logfile_1arg() { return MakeIndirectExec<false, false>(&pg_current_logfile_1arg); }
+TExecFunc arrow_pg_current_snapshot() { return MakeIndirectExec<true, false>(&pg_current_snapshot); }
+TExecFunc arrow_pg_current_xact_id() { return MakeIndirectExec<true, true>(&pg_current_xact_id); }
+TExecFunc arrow_pg_current_xact_id_if_assigned() { return MakeIndirectExec<true, true>(&pg_current_xact_id_if_assigned); }
+TExecFunc arrow_pg_describe_object() { return MakeIndirectExec<true, false>(&pg_describe_object); }
+TExecFunc arrow_pg_drop_replication_slot() { return MakeIndirectExec<true, true>(&pg_drop_replication_slot); }
+TExecFunc arrow_pg_get_object_address() { return MakeIndirectExec<true, false>(&pg_get_object_address); }
+TExecFunc arrow_pg_get_replica_identity_index() { return MakeIndirectExec<true, true>(&pg_get_replica_identity_index); }
+TExecFunc arrow_pg_identify_object() { return MakeIndirectExec<true, false>(&pg_identify_object); }
+TExecFunc arrow_pg_identify_object_as_address() { return MakeIndirectExec<true, false>(&pg_identify_object_as_address); }
+TExecFunc arrow_pg_partition_root() { return MakeIndirectExec<true, true>(&pg_partition_root); }
+TExecFunc arrow_pg_postmaster_start_time() { return MakeIndirectExec<true, true>(&pg_postmaster_start_time); }
+TExecFunc arrow_pg_read_binary_file() { return MakeIndirectExec<true, false>(&pg_read_binary_file); }
+TExecFunc arrow_pg_read_binary_file_all() { return MakeIndirectExec<true, false>(&pg_read_binary_file_all); }
+TExecFunc arrow_pg_read_binary_file_off_len() { return MakeIndirectExec<true, false>(&pg_read_binary_file_off_len); }
+TExecFunc arrow_pg_read_file() { return MakeIndirectExec<true, false>(&pg_read_file); }
+TExecFunc arrow_pg_read_file_all() { return MakeIndirectExec<true, false>(&pg_read_file_all); }
+TExecFunc arrow_pg_read_file_off_len() { return MakeIndirectExec<true, false>(&pg_read_file_off_len); }
+TExecFunc arrow_pg_read_file_v2() { return MakeIndirectExec<true, false>(&pg_read_file_v2); }
+TExecFunc arrow_pg_relation_is_updatable() { return MakeIndirectExec<true, true>(&pg_relation_is_updatable); }
+TExecFunc arrow_pg_replication_slot_advance() { return MakeIndirectExec<true, false>(&pg_replication_slot_advance); }
+TExecFunc arrow_pg_sleep() { return MakeIndirectExec<true, true>(&pg_sleep); }
+TExecFunc arrow_pg_snapshot_in() { return MakeIndirectExec<true, false>(&pg_snapshot_in); }
+TExecFunc arrow_pg_snapshot_out() { return MakeIndirectExec<true, false>(&pg_snapshot_out); }
+TExecFunc arrow_pg_snapshot_recv() { return MakeIndirectExec<true, false>(&pg_snapshot_recv); }
+TExecFunc arrow_pg_snapshot_send() { return MakeIndirectExec<true, false>(&pg_snapshot_send); }
+TExecFunc arrow_pg_snapshot_xmax() { return MakeIndirectExec<true, true>(&pg_snapshot_xmax); }
+TExecFunc arrow_pg_snapshot_xmin() { return MakeIndirectExec<true, true>(&pg_snapshot_xmin); }
+TExecFunc arrow_pg_stat_file() { return MakeIndirectExec<true, false>(&pg_stat_file); }
+TExecFunc arrow_pg_stat_file_1arg() { return MakeIndirectExec<true, false>(&pg_stat_file_1arg); }
+TExecFunc arrow_pg_tablespace_location() { return MakeIndirectExec<true, false>(&pg_tablespace_location); }
+TExecFunc arrow_pg_typeof() { return MakeIndirectExec<false, true>(&pg_typeof); }
+TExecFunc arrow_pg_visible_in_snapshot() { return MakeIndirectExec<true, true>(&pg_visible_in_snapshot); }
+TExecFunc arrow_pg_xact_status() { return MakeIndirectExec<true, false>(&pg_xact_status); }
+TExecFunc arrow_point_above() { return MakeIndirectExec<true, true>(&point_above); }
+TExecFunc arrow_point_add() { return MakeIndirectExec<true, false>(&point_add); }
+TExecFunc arrow_point_below() { return MakeIndirectExec<true, true>(&point_below); }
+TExecFunc arrow_point_box() { return MakeIndirectExec<true, false>(&point_box); }
+TExecFunc arrow_point_distance() { return MakeIndirectExec<true, true>(&point_distance); }
+TExecFunc arrow_point_div() { return MakeIndirectExec<true, false>(&point_div); }
+TExecFunc arrow_point_eq() { return MakeIndirectExec<true, true>(&point_eq); }
+TExecFunc arrow_point_horiz() { return MakeIndirectExec<true, true>(&point_horiz); }
+TExecFunc arrow_point_in() { return MakeIndirectExec<true, false>(&point_in); }
+TExecFunc arrow_point_left() { return MakeIndirectExec<true, true>(&point_left); }
+TExecFunc arrow_point_mul() { return MakeIndirectExec<true, false>(&point_mul); }
+TExecFunc arrow_point_ne() { return MakeIndirectExec<true, true>(&point_ne); }
+TExecFunc arrow_point_out() { return MakeIndirectExec<true, false>(&point_out); }
+TExecFunc arrow_point_recv() { return MakeIndirectExec<true, false>(&point_recv); }
+TExecFunc arrow_point_right() { return MakeIndirectExec<true, true>(&point_right); }
+TExecFunc arrow_point_send() { return MakeIndirectExec<true, false>(&point_send); }
+TExecFunc arrow_point_slope() { return MakeIndirectExec<true, true>(&point_slope); }
+TExecFunc arrow_point_sub() { return MakeIndirectExec<true, false>(&point_sub); }
+TExecFunc arrow_point_vert() { return MakeIndirectExec<true, true>(&point_vert); }
+TExecFunc arrow_points_box() { return MakeIndirectExec<true, false>(&points_box); }
+TExecFunc arrow_poly_above() { return MakeIndirectExec<true, true>(&poly_above); }
+TExecFunc arrow_poly_below() { return MakeIndirectExec<true, true>(&poly_below); }
+TExecFunc arrow_poly_box() { return MakeIndirectExec<true, false>(&poly_box); }
+TExecFunc arrow_poly_center() { return MakeIndirectExec<true, false>(&poly_center); }
+TExecFunc arrow_poly_circle() { return MakeIndirectExec<true, false>(&poly_circle); }
+TExecFunc arrow_poly_contain() { return MakeIndirectExec<true, true>(&poly_contain); }
+TExecFunc arrow_poly_contain_pt() { return MakeIndirectExec<true, true>(&poly_contain_pt); }
+TExecFunc arrow_poly_contained() { return MakeIndirectExec<true, true>(&poly_contained); }
+TExecFunc arrow_poly_distance() { return MakeIndirectExec<true, true>(&poly_distance); }
+TExecFunc arrow_poly_in() { return MakeIndirectExec<true, false>(&poly_in); }
+TExecFunc arrow_poly_left() { return MakeIndirectExec<true, true>(&poly_left); }
+TExecFunc arrow_poly_npoints() { return MakeIndirectExec<true, true>(&poly_npoints); }
+TExecFunc arrow_poly_out() { return MakeIndirectExec<true, false>(&poly_out); }
+TExecFunc arrow_poly_overabove() { return MakeIndirectExec<true, true>(&poly_overabove); }
+TExecFunc arrow_poly_overbelow() { return MakeIndirectExec<true, true>(&poly_overbelow); }
+TExecFunc arrow_poly_overlap() { return MakeIndirectExec<true, true>(&poly_overlap); }
+TExecFunc arrow_poly_overleft() { return MakeIndirectExec<true, true>(&poly_overleft); }
+TExecFunc arrow_poly_overright() { return MakeIndirectExec<true, true>(&poly_overright); }
+TExecFunc arrow_poly_path() { return MakeIndirectExec<true, false>(&poly_path); }
+TExecFunc arrow_poly_recv() { return MakeIndirectExec<true, false>(&poly_recv); }
+TExecFunc arrow_poly_right() { return MakeIndirectExec<true, true>(&poly_right); }
+TExecFunc arrow_poly_same() { return MakeIndirectExec<true, true>(&poly_same); }
+TExecFunc arrow_poly_send() { return MakeIndirectExec<true, false>(&poly_send); }
+TExecFunc arrow_positionjoinsel() { return MakeIndirectExec<true, true>(&positionjoinsel); }
+TExecFunc arrow_positionsel() { return MakeIndirectExec<true, true>(&positionsel); }
+TExecFunc arrow_postgresql_fdw_validator() { return MakeIndirectExec<true, true>(&postgresql_fdw_validator); }
+TExecFunc arrow_prefixjoinsel() { return MakeIndirectExec<true, true>(&prefixjoinsel); }
+TExecFunc arrow_prefixsel() { return MakeIndirectExec<true, true>(&prefixsel); }
+TExecFunc arrow_pt_contained_circle() { return MakeIndirectExec<true, true>(&pt_contained_circle); }
+TExecFunc arrow_pt_contained_poly() { return MakeIndirectExec<true, true>(&pt_contained_poly); }
+TExecFunc arrow_quote_ident() { return MakeIndirectExec<true, false>(&quote_ident); }
+TExecFunc arrow_quote_literal() { return MakeIndirectExec<true, false>(&quote_literal); }
+TExecFunc arrow_quote_nullable() { return MakeIndirectExec<false, false>(&quote_nullable); }
+TExecFunc arrow_regclassin() { return MakeIndirectExec<true, true>(&regclassin); }
+TExecFunc arrow_regclassout() { return MakeIndirectExec<true, false>(&regclassout); }
+TExecFunc arrow_regclassrecv() { return MakeIndirectExec<true, true>(&regclassrecv); }
+TExecFunc arrow_regclasssend() { return MakeIndirectExec<true, false>(&regclasssend); }
+TExecFunc arrow_regcollationin() { return MakeIndirectExec<true, true>(&regcollationin); }
+TExecFunc arrow_regcollationout() { return MakeIndirectExec<true, false>(&regcollationout); }
+TExecFunc arrow_regcollationrecv() { return MakeIndirectExec<true, true>(&regcollationrecv); }
+TExecFunc arrow_regcollationsend() { return MakeIndirectExec<true, false>(&regcollationsend); }
+TExecFunc arrow_regconfigin() { return MakeIndirectExec<true, true>(&regconfigin); }
+TExecFunc arrow_regconfigout() { return MakeIndirectExec<true, false>(&regconfigout); }
+TExecFunc arrow_regconfigrecv() { return MakeIndirectExec<true, true>(&regconfigrecv); }
+TExecFunc arrow_regconfigsend() { return MakeIndirectExec<true, false>(&regconfigsend); }
+TExecFunc arrow_regdictionaryin() { return MakeIndirectExec<true, true>(&regdictionaryin); }
+TExecFunc arrow_regdictionaryout() { return MakeIndirectExec<true, false>(&regdictionaryout); }
+TExecFunc arrow_regdictionaryrecv() { return MakeIndirectExec<true, true>(&regdictionaryrecv); }
+TExecFunc arrow_regdictionarysend() { return MakeIndirectExec<true, false>(&regdictionarysend); }
+TExecFunc arrow_regexeqjoinsel() { return MakeIndirectExec<true, true>(&regexeqjoinsel); }
+TExecFunc arrow_regexeqsel() { return MakeIndirectExec<true, true>(&regexeqsel); }
+TExecFunc arrow_regexnejoinsel() { return MakeIndirectExec<true, true>(&regexnejoinsel); }
+TExecFunc arrow_regexnesel() { return MakeIndirectExec<true, true>(&regexnesel); }
+TExecFunc arrow_regnamespacein() { return MakeIndirectExec<true, true>(&regnamespacein); }
+TExecFunc arrow_regnamespaceout() { return MakeIndirectExec<true, false>(&regnamespaceout); }
+TExecFunc arrow_regnamespacerecv() { return MakeIndirectExec<true, true>(&regnamespacerecv); }
+TExecFunc arrow_regnamespacesend() { return MakeIndirectExec<true, false>(&regnamespacesend); }
+TExecFunc arrow_regoperatorin() { return MakeIndirectExec<true, true>(&regoperatorin); }
+TExecFunc arrow_regoperatorout() { return MakeIndirectExec<true, false>(&regoperatorout); }
+TExecFunc arrow_regoperatorrecv() { return MakeIndirectExec<true, true>(&regoperatorrecv); }
+TExecFunc arrow_regoperatorsend() { return MakeIndirectExec<true, false>(&regoperatorsend); }
+TExecFunc arrow_regoperin() { return MakeIndirectExec<true, true>(&regoperin); }
+TExecFunc arrow_regoperout() { return MakeIndirectExec<true, false>(&regoperout); }
+TExecFunc arrow_regoperrecv() { return MakeIndirectExec<true, true>(&regoperrecv); }
+TExecFunc arrow_regopersend() { return MakeIndirectExec<true, false>(&regopersend); }
+TExecFunc arrow_regprocedurein() { return MakeIndirectExec<true, true>(&regprocedurein); }
+TExecFunc arrow_regprocedureout() { return MakeIndirectExec<true, false>(&regprocedureout); }
+TExecFunc arrow_regprocedurerecv() { return MakeIndirectExec<true, true>(&regprocedurerecv); }
+TExecFunc arrow_regproceduresend() { return MakeIndirectExec<true, false>(&regproceduresend); }
+TExecFunc arrow_regprocin() { return MakeIndirectExec<true, true>(&regprocin); }
+TExecFunc arrow_regprocout() { return MakeIndirectExec<true, false>(&regprocout); }
+TExecFunc arrow_regprocrecv() { return MakeIndirectExec<true, true>(&regprocrecv); }
+TExecFunc arrow_regprocsend() { return MakeIndirectExec<true, false>(&regprocsend); }
+TExecFunc arrow_regrolein() { return MakeIndirectExec<true, true>(&regrolein); }
+TExecFunc arrow_regroleout() { return MakeIndirectExec<true, false>(&regroleout); }
+TExecFunc arrow_regrolerecv() { return MakeIndirectExec<true, true>(&regrolerecv); }
+TExecFunc arrow_regrolesend() { return MakeIndirectExec<true, false>(&regrolesend); }
+TExecFunc arrow_regtypein() { return MakeIndirectExec<true, true>(&regtypein); }
+TExecFunc arrow_regtypeout() { return MakeIndirectExec<true, false>(&regtypeout); }
+TExecFunc arrow_regtyperecv() { return MakeIndirectExec<true, true>(&regtyperecv); }
+TExecFunc arrow_regtypesend() { return MakeIndirectExec<true, false>(&regtypesend); }
+TExecFunc arrow_row_security_active() { return MakeIndirectExec<true, true>(&row_security_active); }
+TExecFunc arrow_row_security_active_name() { return MakeIndirectExec<true, true>(&row_security_active_name); }
+TExecFunc arrow_sha224_bytea() { return MakeIndirectExec<true, false>(&sha224_bytea); }
+TExecFunc arrow_sha256_bytea() { return MakeIndirectExec<true, false>(&sha256_bytea); }
+TExecFunc arrow_sha384_bytea() { return MakeIndirectExec<true, false>(&sha384_bytea); }
+TExecFunc arrow_sha512_bytea() { return MakeIndirectExec<true, false>(&sha512_bytea); }
+TExecFunc arrow_spg_bbox_quad_config() { return MakeIndirectExec<true, true>(&spg_bbox_quad_config); }
+TExecFunc arrow_spg_box_quad_choose() { return MakeIndirectExec<true, true>(&spg_box_quad_choose); }
+TExecFunc arrow_spg_box_quad_config() { return MakeIndirectExec<true, true>(&spg_box_quad_config); }
+TExecFunc arrow_spg_box_quad_inner_consistent() { return MakeIndirectExec<true, true>(&spg_box_quad_inner_consistent); }
+TExecFunc arrow_spg_box_quad_leaf_consistent() { return MakeIndirectExec<true, true>(&spg_box_quad_leaf_consistent); }
+TExecFunc arrow_spg_box_quad_picksplit() { return MakeIndirectExec<true, true>(&spg_box_quad_picksplit); }
+TExecFunc arrow_spg_poly_quad_compress() { return MakeIndirectExec<true, false>(&spg_poly_quad_compress); }
+TExecFunc arrow_statement_timestamp() { return MakeIndirectExec<true, true>(&statement_timestamp); }
+TExecFunc arrow_text_regclass() { return MakeIndirectExec<true, true>(&text_regclass); }
+TExecFunc arrow_texticlike_support() { return MakeIndirectExec<true, true>(&texticlike_support); }
+TExecFunc arrow_texticregexeq_support() { return MakeIndirectExec<true, true>(&texticregexeq_support); }
+TExecFunc arrow_textlike_support() { return MakeIndirectExec<true, true>(&textlike_support); }
+TExecFunc arrow_textregexeq_support() { return MakeIndirectExec<true, true>(&textregexeq_support); }
+TExecFunc arrow_thesaurus_init() { return MakeIndirectExec<true, true>(&thesaurus_init); }
+TExecFunc arrow_thesaurus_lexize() { return MakeIndirectExec<true, true>(&thesaurus_lexize); }
+TExecFunc arrow_tideq() { return MakeIndirectExec<true, true>(&tideq); }
+TExecFunc arrow_tidge() { return MakeIndirectExec<true, true>(&tidge); }
+TExecFunc arrow_tidgt() { return MakeIndirectExec<true, true>(&tidgt); }
+TExecFunc arrow_tidin() { return MakeIndirectExec<true, false>(&tidin); }
+TExecFunc arrow_tidlarger() { return MakeIndirectExec<true, false>(&tidlarger); }
+TExecFunc arrow_tidle() { return MakeIndirectExec<true, true>(&tidle); }
+TExecFunc arrow_tidlt() { return MakeIndirectExec<true, true>(&tidlt); }
+TExecFunc arrow_tidne() { return MakeIndirectExec<true, true>(&tidne); }
+TExecFunc arrow_tidout() { return MakeIndirectExec<true, false>(&tidout); }
+TExecFunc arrow_tidrecv() { return MakeIndirectExec<true, false>(&tidrecv); }
+TExecFunc arrow_tidsend() { return MakeIndirectExec<true, false>(&tidsend); }
+TExecFunc arrow_tidsmaller() { return MakeIndirectExec<true, false>(&tidsmaller); }
+TExecFunc arrow_timeofday() { return MakeIndirectExec<true, false>(&timeofday); }
+TExecFunc arrow_timestamp_age() { return MakeIndirectExec<true, false>(&timestamp_age); }
+TExecFunc arrow_timestamp_bin() { return MakeIndirectExec<true, true>(&timestamp_bin); }
+TExecFunc arrow_timestamp_cmp() { return MakeIndirectExec<true, true>(&timestamp_cmp); }
+TExecFunc arrow_timestamp_cmp_timestamptz() { return MakeIndirectExec<true, true>(&timestamp_cmp_timestamptz); }
+TExecFunc arrow_timestamp_eq() { return MakeIndirectExec<true, true>(&timestamp_eq); }
+TExecFunc arrow_timestamp_eq_timestamptz() { return MakeIndirectExec<true, true>(&timestamp_eq_timestamptz); }
+TExecFunc arrow_timestamp_finite() { return MakeIndirectExec<true, true>(&timestamp_finite); }
+TExecFunc arrow_timestamp_ge() { return MakeIndirectExec<true, true>(&timestamp_ge); }
+TExecFunc arrow_timestamp_ge_timestamptz() { return MakeIndirectExec<true, true>(&timestamp_ge_timestamptz); }
+TExecFunc arrow_timestamp_gt() { return MakeIndirectExec<true, true>(&timestamp_gt); }
+TExecFunc arrow_timestamp_gt_timestamptz() { return MakeIndirectExec<true, true>(&timestamp_gt_timestamptz); }
+TExecFunc arrow_timestamp_hash() { return MakeIndirectExec<true, true>(&timestamp_hash); }
+TExecFunc arrow_timestamp_hash_extended() { return MakeIndirectExec<true, true>(&timestamp_hash_extended); }
+TExecFunc arrow_timestamp_in() { return MakeIndirectExec<true, true>(&timestamp_in); }
+TExecFunc arrow_timestamp_izone() { return MakeIndirectExec<true, true>(&timestamp_izone); }
+TExecFunc arrow_timestamp_larger() { return MakeIndirectExec<true, true>(&timestamp_larger); }
+TExecFunc arrow_timestamp_le() { return MakeIndirectExec<true, true>(&timestamp_le); }
+TExecFunc arrow_timestamp_le_timestamptz() { return MakeIndirectExec<true, true>(&timestamp_le_timestamptz); }
+TExecFunc arrow_timestamp_lt() { return MakeIndirectExec<true, true>(&timestamp_lt); }
+TExecFunc arrow_timestamp_lt_timestamptz() { return MakeIndirectExec<true, true>(&timestamp_lt_timestamptz); }
+TExecFunc arrow_timestamp_mi() { return MakeIndirectExec<true, false>(&timestamp_mi); }
+TExecFunc arrow_timestamp_mi_interval() { return MakeIndirectExec<true, true>(&timestamp_mi_interval); }
+TExecFunc arrow_timestamp_ne() { return MakeIndirectExec<true, true>(&timestamp_ne); }
+TExecFunc arrow_timestamp_ne_timestamptz() { return MakeIndirectExec<true, true>(&timestamp_ne_timestamptz); }
+TExecFunc arrow_timestamp_out() { return MakeIndirectExec<true, false>(&timestamp_out); }
+TExecFunc arrow_timestamp_part() { return MakeIndirectExec<true, true>(&timestamp_part); }
+TExecFunc arrow_timestamp_pl_interval() { return MakeIndirectExec<true, true>(&timestamp_pl_interval); }
+TExecFunc arrow_timestamp_recv() { return MakeIndirectExec<true, true>(&timestamp_recv); }
+TExecFunc arrow_timestamp_scale() { return MakeIndirectExec<true, true>(&timestamp_scale); }
+TExecFunc arrow_timestamp_send() { return MakeIndirectExec<true, false>(&timestamp_send); }
+TExecFunc arrow_timestamp_smaller() { return MakeIndirectExec<true, true>(&timestamp_smaller); }
+TExecFunc arrow_timestamp_sortsupport() { return MakeIndirectExec<true, true>(&timestamp_sortsupport); }
+TExecFunc arrow_timestamp_support() { return MakeIndirectExec<true, true>(&timestamp_support); }
+TExecFunc arrow_timestamp_timestamptz() { return MakeIndirectExec<true, true>(&timestamp_timestamptz); }
+TExecFunc arrow_timestamp_to_char() { return MakeIndirectExec<true, false>(&timestamp_to_char); }
+TExecFunc arrow_timestamp_trunc() { return MakeIndirectExec<true, true>(&timestamp_trunc); }
+TExecFunc arrow_timestamp_zone() { return MakeIndirectExec<true, true>(&timestamp_zone); }
+TExecFunc arrow_timestamptypmodin() { return MakeIndirectExec<true, true>(&timestamptypmodin); }
+TExecFunc arrow_timestamptypmodout() { return MakeIndirectExec<true, false>(&timestamptypmodout); }
+TExecFunc arrow_timestamptz_age() { return MakeIndirectExec<true, false>(&timestamptz_age); }
+TExecFunc arrow_timestamptz_bin() { return MakeIndirectExec<true, true>(&timestamptz_bin); }
+TExecFunc arrow_timestamptz_cmp_timestamp() { return MakeIndirectExec<true, true>(&timestamptz_cmp_timestamp); }
+TExecFunc arrow_timestamptz_eq_timestamp() { return MakeIndirectExec<true, true>(&timestamptz_eq_timestamp); }
+TExecFunc arrow_timestamptz_ge_timestamp() { return MakeIndirectExec<true, true>(&timestamptz_ge_timestamp); }
+TExecFunc arrow_timestamptz_gt_timestamp() { return MakeIndirectExec<true, true>(&timestamptz_gt_timestamp); }
+TExecFunc arrow_timestamptz_in() { return MakeIndirectExec<true, true>(&timestamptz_in); }
+TExecFunc arrow_timestamptz_izone() { return MakeIndirectExec<true, true>(&timestamptz_izone); }
+TExecFunc arrow_timestamptz_le_timestamp() { return MakeIndirectExec<true, true>(&timestamptz_le_timestamp); }
+TExecFunc arrow_timestamptz_lt_timestamp() { return MakeIndirectExec<true, true>(&timestamptz_lt_timestamp); }
+TExecFunc arrow_timestamptz_mi_interval() { return MakeIndirectExec<true, true>(&timestamptz_mi_interval); }
+TExecFunc arrow_timestamptz_ne_timestamp() { return MakeIndirectExec<true, true>(&timestamptz_ne_timestamp); }
+TExecFunc arrow_timestamptz_out() { return MakeIndirectExec<true, false>(&timestamptz_out); }
+TExecFunc arrow_timestamptz_part() { return MakeIndirectExec<true, true>(&timestamptz_part); }
+TExecFunc arrow_timestamptz_pl_interval() { return MakeIndirectExec<true, true>(&timestamptz_pl_interval); }
+TExecFunc arrow_timestamptz_recv() { return MakeIndirectExec<true, true>(&timestamptz_recv); }
+TExecFunc arrow_timestamptz_scale() { return MakeIndirectExec<true, true>(&timestamptz_scale); }
+TExecFunc arrow_timestamptz_send() { return MakeIndirectExec<true, false>(&timestamptz_send); }
+TExecFunc arrow_timestamptz_timestamp() { return MakeIndirectExec<true, true>(&timestamptz_timestamp); }
+TExecFunc arrow_timestamptz_to_char() { return MakeIndirectExec<true, false>(&timestamptz_to_char); }
+TExecFunc arrow_timestamptz_trunc() { return MakeIndirectExec<true, true>(&timestamptz_trunc); }
+TExecFunc arrow_timestamptz_trunc_zone() { return MakeIndirectExec<true, true>(&timestamptz_trunc_zone); }
+TExecFunc arrow_timestamptz_zone() { return MakeIndirectExec<true, true>(&timestamptz_zone); }
+TExecFunc arrow_timestamptztypmodin() { return MakeIndirectExec<true, true>(&timestamptztypmodin); }
+TExecFunc arrow_timestamptztypmodout() { return MakeIndirectExec<true, false>(&timestamptztypmodout); }
+TExecFunc arrow_to_ascii_default() { return MakeIndirectExec<true, false>(&to_ascii_default); }
+TExecFunc arrow_to_ascii_enc() { return MakeIndirectExec<true, false>(&to_ascii_enc); }
+TExecFunc arrow_to_ascii_encname() { return MakeIndirectExec<true, false>(&to_ascii_encname); }
+TExecFunc arrow_to_date() { return MakeIndirectExec<true, true>(&to_date); }
+TExecFunc arrow_to_regclass() { return MakeIndirectExec<true, true>(&to_regclass); }
+TExecFunc arrow_to_regcollation() { return MakeIndirectExec<true, true>(&to_regcollation); }
+TExecFunc arrow_to_regnamespace() { return MakeIndirectExec<true, true>(&to_regnamespace); }
+TExecFunc arrow_to_regoper() { return MakeIndirectExec<true, true>(&to_regoper); }
+TExecFunc arrow_to_regoperator() { return MakeIndirectExec<true, true>(&to_regoperator); }
+TExecFunc arrow_to_regproc() { return MakeIndirectExec<true, true>(&to_regproc); }
+TExecFunc arrow_to_regprocedure() { return MakeIndirectExec<true, true>(&to_regprocedure); }
+TExecFunc arrow_to_regrole() { return MakeIndirectExec<true, true>(&to_regrole); }
+TExecFunc arrow_to_regtype() { return MakeIndirectExec<true, true>(&to_regtype); }
+TExecFunc arrow_to_timestamp() { return MakeIndirectExec<true, true>(&to_timestamp); }
+TExecFunc arrow_ts_lexize() { return MakeIndirectExec<true, false>(&ts_lexize); }
+TExecFunc arrow_ts_typanalyze() { return MakeIndirectExec<true, true>(&ts_typanalyze); }
+TExecFunc arrow_tsm_bernoulli_handler() { return MakeIndirectExec<true, true>(&tsm_bernoulli_handler); }
+TExecFunc arrow_tsmatchjoinsel() { return MakeIndirectExec<true, true>(&tsmatchjoinsel); }
+TExecFunc arrow_tsmatchsel() { return MakeIndirectExec<true, true>(&tsmatchsel); }
+TExecFunc arrow_tsquery_rewrite() { return MakeIndirectExec<true, false>(&tsquery_rewrite); }
+TExecFunc arrow_tsquery_rewrite_query() { return MakeIndirectExec<true, false>(&tsquery_rewrite_query); }
+TExecFunc arrow_varbit() { return MakeIndirectExec<true, false>(&varbit); }
+TExecFunc arrow_varbit_in() { return MakeIndirectExec<true, false>(&varbit_in); }
+TExecFunc arrow_varbit_out() { return MakeIndirectExec<true, false>(&varbit_out); }
+TExecFunc arrow_varbit_recv() { return MakeIndirectExec<true, false>(&varbit_recv); }
+TExecFunc arrow_varbit_send() { return MakeIndirectExec<true, false>(&varbit_send); }
+TExecFunc arrow_varbit_support() { return MakeIndirectExec<true, true>(&varbit_support); }
+TExecFunc arrow_varbittypmodin() { return MakeIndirectExec<true, true>(&varbittypmodin); }
+TExecFunc arrow_varbittypmodout() { return MakeIndirectExec<true, false>(&varbittypmodout); }
+TExecFunc arrow_width_bucket_numeric() { return MakeIndirectExec<true, true>(&width_bucket_numeric); }
diff --git a/ydb/library/yql/parser/pg_wrapper/pg_kernels_register.0.inc b/ydb/library/yql/parser/pg_wrapper/pg_kernels_register.0.inc
index 890c4a14966..0d904bf6957 100644
--- a/ydb/library/yql/parser/pg_wrapper/pg_kernels_register.0.inc
+++ b/ydb/library/yql/parser/pg_wrapper/pg_kernels_register.0.inc
@@ -1,99 +1,135 @@
-RegisterExec(38, arrow_int2in());
-RegisterExec(39, arrow_int2out());
-RegisterExec(40, arrow_int2vectorin());
-RegisterExec(41, arrow_int2vectorout());
-RegisterExec(42, arrow_int4in());
-RegisterExec(43, arrow_int4out());
+RegisterExec(3, arrow_heap_tableam_handler());
+RegisterExec(33, arrow_charout());
+RegisterExec(54, arrow_oidvectorin());
+RegisterExec(55, arrow_oidvectorout());
 RegisterExec(56, arrow_boollt());
 RegisterExec(57, arrow_boolgt());
 RegisterExec(60, arrow_booleq());
-RegisterExec(63, arrow_int2eq());
-RegisterExec(64, arrow_int2lt());
-RegisterExec(65, arrow_int4eq());
-RegisterExec(66, arrow_int4lt());
+RegisterExec(61, arrow_chareq());
+RegisterExec(70, arrow_charne());
+RegisterExec(72, arrow_charle());
+RegisterExec(73, arrow_chargt());
+RegisterExec(74, arrow_charge());
+RegisterExec(77, arrow_chartoi4());
+RegisterExec(78, arrow_i4tochar());
+RegisterExec(79, arrow_nameregexeq());
 RegisterExec(84, arrow_boolne());
-RegisterExec(86, arrow_pg_ddl_command_in());
-RegisterExec(87, arrow_pg_ddl_command_out());
-RegisterExec(88, arrow_pg_ddl_command_recv());
-RegisterExec(90, arrow_pg_ddl_command_send());
-RegisterExec(141, arrow_int4mul());
-RegisterExec(144, arrow_int4ne());
-RegisterExec(145, arrow_int2ne());
-RegisterExec(146, arrow_int2gt());
-RegisterExec(147, arrow_int4gt());
-RegisterExec(148, arrow_int2le());
-RegisterExec(149, arrow_int4le());
-RegisterExec(150, arrow_int4ge());
-RegisterExec(151, arrow_int2ge());
-RegisterExec(152, arrow_int2mul());
-RegisterExec(153, arrow_int2div());
-RegisterExec(154, arrow_int4div());
-RegisterExec(155, arrow_int2mod());
-RegisterExec(940, arrow_int2mod());
-RegisterExec(156, arrow_int4mod());
-RegisterExec(941, arrow_int4mod());
-RegisterExec(158, arrow_int24eq());
-RegisterExec(159, arrow_int42eq());
-RegisterExec(160, arrow_int24lt());
-RegisterExec(161, arrow_int42lt());
-RegisterExec(162, arrow_int24gt());
-RegisterExec(163, arrow_int42gt());
-RegisterExec(164, arrow_int24ne());
-RegisterExec(165, arrow_int42ne());
-RegisterExec(166, arrow_int24le());
-RegisterExec(167, arrow_int42le());
-RegisterExec(168, arrow_int24ge());
-RegisterExec(169, arrow_int42ge());
-RegisterExec(170, arrow_int24mul());
-RegisterExec(171, arrow_int42mul());
-RegisterExec(172, arrow_int24div());
-RegisterExec(173, arrow_int42div());
-RegisterExec(176, arrow_int2pl());
-RegisterExec(177, arrow_int4pl());
-RegisterExec(178, arrow_int24pl());
-RegisterExec(179, arrow_int42pl());
-RegisterExec(180, arrow_int2mi());
-RegisterExec(181, arrow_int4mi());
-RegisterExec(182, arrow_int24mi());
-RegisterExec(183, arrow_int42mi());
-RegisterExec(195, arrow_pg_node_tree_in());
-RegisterExec(196, arrow_pg_node_tree_out());
-RegisterExec(197, arrow_pg_node_tree_recv());
-RegisterExec(198, arrow_pg_node_tree_send());
-RegisterExec(212, arrow_int4um());
-RegisterExec(213, arrow_int2um());
-RegisterExec(267, arrow_table_am_handler_in());
-RegisterExec(268, arrow_table_am_handler_out());
-RegisterExec(274, arrow_timeofday());
-RegisterExec(313, arrow_i2toi4());
-RegisterExec(314, arrow_i4toi2());
-RegisterExec(326, arrow_index_am_handler_in());
-RegisterExec(327, arrow_index_am_handler_out());
-RegisterExec(334, arrow_spghandler());
-RegisterExec(338, arrow_amvalidate());
-RegisterExec(399, arrow_hashmacaddr());
-RegisterExec(432, arrow_hash_numeric());
-RegisterExec(436, arrow_macaddr_in());
-RegisterExec(437, arrow_macaddr_out());
+RegisterExec(89, arrow_pgsql_version());
+RegisterExec(101, arrow_eqsel());
+RegisterExec(102, arrow_neqsel());
+RegisterExec(103, arrow_scalarltsel());
+RegisterExec(104, arrow_scalargtsel());
+RegisterExec(105, arrow_eqjoinsel());
+RegisterExec(106, arrow_neqjoinsel());
+RegisterExec(107, arrow_scalarltjoinsel());
+RegisterExec(108, arrow_scalargtjoinsel());
+RegisterExec(184, arrow_oideq());
+RegisterExec(185, arrow_oidne());
+RegisterExec(275, arrow_pg_nextoid());
+RegisterExec(321, arrow_json_in());
+RegisterExec(322, arrow_json_out());
+RegisterExec(323, arrow_json_recv());
+RegisterExec(324, arrow_json_send());
+RegisterExec(328, arrow_hashmacaddr8());
+RegisterExec(332, arrow_gisthandler());
+RegisterExec(335, arrow_brinhandler());
+RegisterExec(336, arrow_scalarlesel());
+RegisterExec(337, arrow_scalargesel());
+RegisterExec(350, arrow_btint2cmp());
+RegisterExec(351, arrow_btint4cmp());
+RegisterExec(356, arrow_btoidcmp());
+RegisterExec(358, arrow_btcharcmp());
+RegisterExec(386, arrow_scalarlejoinsel());
+RegisterExec(398, arrow_scalargejoinsel());
+RegisterExec(400, arrow_hashtext());
+RegisterExec(401, arrow_rtrim1());
+RegisterExec(882, arrow_rtrim1());
+RegisterExec(404, arrow_btoidvectorcmp());
+RegisterExec(422, arrow_hashinet());
+RegisterExec(425, arrow_hashint4extended());
+RegisterExec(441, arrow_hashint2extended());
+RegisterExec(442, arrow_hashint8extended());
+RegisterExec(443, arrow_hashfloat4extended());
+RegisterExec(444, arrow_hashfloat8extended());
+RegisterExec(445, arrow_hashoidextended());
+RegisterExec(446, arrow_hashcharextended());
+RegisterExec(447, arrow_hashnameextended());
+RegisterExec(448, arrow_hashtextextended());
+RegisterExec(449, arrow_hashint2());
+RegisterExec(450, arrow_hashint4());
+RegisterExec(451, arrow_hashfloat4());
+RegisterExec(452, arrow_hashfloat8());
+RegisterExec(453, arrow_hashoid());
+RegisterExec(454, arrow_hashchar());
+RegisterExec(455, arrow_hashname());
+RegisterExec(456, arrow_hashvarlena());
+RegisterExec(457, arrow_hashoidvector());
+RegisterExec(598, arrow_inet_abbrev());
+RegisterExec(599, arrow_cidr_abbrev());
+RegisterExec(605, arrow_inet_set_masklen());
+RegisterExec(619, arrow_oidvectorne());
+RegisterExec(635, arrow_cidr_set_masklen());
+RegisterExec(677, arrow_oidvectorlt());
+RegisterExec(678, arrow_oidvectorle());
+RegisterExec(679, arrow_oidvectoreq());
+RegisterExec(680, arrow_oidvectorge());
+RegisterExec(681, arrow_oidvectorgt());
+RegisterExec(683, arrow_network_network());
+RegisterExec(696, arrow_network_netmask());
+RegisterExec(697, arrow_network_masklen());
+RegisterExec(698, arrow_network_broadcast());
+RegisterExec(699, arrow_network_host());
+RegisterExec(711, arrow_network_family());
 RegisterExec(715, arrow_be_lo_create());
-RegisterExec(753, arrow_macaddr_trunc());
+RegisterExec(716, arrow_oidlt());
+RegisterExec(717, arrow_oidle());
+RegisterExec(730, arrow_network_show());
 RegisterExec(764, arrow_be_lo_import());
 RegisterExec(765, arrow_be_lo_export());
-RegisterExec(766, arrow_int4inc());
 RegisterExec(767, arrow_be_lo_import_with_oid());
-RegisterExec(768, arrow_int4larger());
-RegisterExec(769, arrow_int4smaller());
-RegisterExec(770, arrow_int2larger());
-RegisterExec(771, arrow_int2smaller());
-RegisterExec(778, arrow_hashmacaddrextended());
-RegisterExec(780, arrow_hash_numeric_extended());
-RegisterExec(830, arrow_macaddr_eq());
-RegisterExec(831, arrow_macaddr_lt());
-RegisterExec(832, arrow_macaddr_le());
-RegisterExec(833, arrow_macaddr_gt());
-RegisterExec(834, arrow_macaddr_ge());
-RegisterExec(835, arrow_macaddr_ne());
-RegisterExec(836, arrow_macaddr_cmp());
+RegisterExec(772, arrow_hashvarlenaextended());
+RegisterExec(776, arrow_hashoidvectorextended());
+RegisterExec(779, arrow_hashinetextended());
+RegisterExec(781, arrow_hashmacaddr8extended());
+RegisterExec(810, arrow_pg_client_encoding());
+RegisterExec(842, arrow_btint8cmp());
+RegisterExec(850, arrow_textlike());
+RegisterExec(1569, arrow_textlike());
+RegisterExec(1631, arrow_textlike());
+RegisterExec(851, arrow_textnlike());
+RegisterExec(1570, arrow_textnlike());
+RegisterExec(1632, arrow_textnlike());
+RegisterExec(858, arrow_namelike());
+RegisterExec(1571, arrow_namelike());
+RegisterExec(859, arrow_namenlike());
+RegisterExec(1572, arrow_namenlike());
+RegisterExec(870, arrow_lower());
+RegisterExec(871, arrow_upper());
+RegisterExec(872, arrow_initcap());
+RegisterExec(873, arrow_lpad());
+RegisterExec(874, arrow_rpad());
+RegisterExec(875, arrow_ltrim());
+RegisterExec(876, arrow_rtrim());
+RegisterExec(878, arrow_translate());
+RegisterExec(881, arrow_ltrim1());
+RegisterExec(884, arrow_btrim());
+RegisterExec(885, arrow_btrim1());
+RegisterExec(910, arrow_inet_in());
+RegisterExec(911, arrow_inet_out());
+RegisterExec(920, arrow_network_eq());
+RegisterExec(921, arrow_network_lt());
+RegisterExec(922, arrow_network_le());
+RegisterExec(923, arrow_network_gt());
+RegisterExec(924, arrow_network_ge());
+RegisterExec(925, arrow_network_ne());
+RegisterExec(926, arrow_network_cmp());
+RegisterExec(927, arrow_network_sub());
+RegisterExec(928, arrow_network_subeq());
+RegisterExec(929, arrow_network_sup());
+RegisterExec(930, arrow_network_supeq());
+RegisterExec(944, arrow_text_char());
+RegisterExec(946, arrow_char_text());
+RegisterExec(949, arrow_hashint8());
 RegisterExec(952, arrow_be_lo_open());
 RegisterExec(953, arrow_be_lo_close());
 RegisterExec(954, arrow_be_loread());
@@ -103,437 +139,220 @@ RegisterExec(957, arrow_be_lo_creat());
 RegisterExec(958, arrow_be_lo_tell());
 RegisterExec(964, arrow_be_lo_unlink());
 RegisterExec(1004, arrow_be_lo_truncate());
-RegisterExec(1023, arrow_textlike_support());
-RegisterExec(1024, arrow_texticregexeq_support());
-RegisterExec(1025, arrow_texticlike_support());
-RegisterExec(1026, arrow_timestamptz_izone());
-RegisterExec(1150, arrow_timestamptz_in());
-RegisterExec(1151, arrow_timestamptz_out());
-RegisterExec(1152, arrow_timestamp_eq());
-RegisterExec(2052, arrow_timestamp_eq());
-RegisterExec(1153, arrow_timestamp_ne());
-RegisterExec(2053, arrow_timestamp_ne());
-RegisterExec(1154, arrow_timestamp_lt());
-RegisterExec(2054, arrow_timestamp_lt());
-RegisterExec(1155, arrow_timestamp_le());
-RegisterExec(2055, arrow_timestamp_le());
-RegisterExec(1156, arrow_timestamp_ge());
-RegisterExec(2056, arrow_timestamp_ge());
-RegisterExec(1157, arrow_timestamp_gt());
-RegisterExec(2057, arrow_timestamp_gt());
-RegisterExec(1158, arrow_float8_timestamptz());
-RegisterExec(1159, arrow_timestamptz_zone());
-RegisterExec(1160, arrow_interval_in());
-RegisterExec(1161, arrow_interval_out());
-RegisterExec(1162, arrow_interval_eq());
-RegisterExec(1163, arrow_interval_ne());
-RegisterExec(1164, arrow_interval_lt());
-RegisterExec(1165, arrow_interval_le());
-RegisterExec(1166, arrow_interval_ge());
-RegisterExec(1167, arrow_interval_gt());
-RegisterExec(1168, arrow_interval_um());
-RegisterExec(1169, arrow_interval_pl());
-RegisterExec(1170, arrow_interval_mi());
-RegisterExec(1171, arrow_timestamptz_part());
-RegisterExec(1172, arrow_interval_part());
-RegisterExec(1175, arrow_interval_justify_hours());
-RegisterExec(1177, arrow_jsonb_path_exists_tz());
-RegisterExec(1180, arrow_jsonb_path_query_array_tz());
-RegisterExec(1188, arrow_timestamp_mi());
-RegisterExec(2031, arrow_timestamp_mi());
-RegisterExec(1189, arrow_timestamptz_pl_interval());
-RegisterExec(1190, arrow_timestamptz_mi_interval());
-RegisterExec(1195, arrow_timestamp_smaller());
-RegisterExec(2035, arrow_timestamp_smaller());
-RegisterExec(1196, arrow_timestamp_larger());
-RegisterExec(2036, arrow_timestamp_larger());
-RegisterExec(1197, arrow_interval_smaller());
-RegisterExec(1198, arrow_interval_larger());
-RegisterExec(1199, arrow_timestamptz_age());
-RegisterExec(1200, arrow_interval_scale());
-RegisterExec(1217, arrow_timestamptz_trunc());
-RegisterExec(1218, arrow_interval_trunc());
+RegisterExec(1039, arrow_getdatabaseencoding());
+RegisterExec(1081, arrow_format_type());
+RegisterExec(1173, arrow_network_subset_support());
+RegisterExec(1238, arrow_texticregexeq());
+RegisterExec(1656, arrow_texticregexeq());
+RegisterExec(1239, arrow_texticregexne());
+RegisterExec(1657, arrow_texticregexne());
+RegisterExec(1240, arrow_nameicregexeq());
+RegisterExec(1241, arrow_nameicregexne());
 RegisterExec(1242, arrow_boolin());
 RegisterExec(1243, arrow_boolout());
-RegisterExec(1251, arrow_int4abs());
-RegisterExec(1397, arrow_int4abs());
-RegisterExec(1253, arrow_int2abs());
-RegisterExec(1398, arrow_int2abs());
-RegisterExec(1284, arrow_timestamptz_trunc_zone());
-RegisterExec(1291, arrow_suppress_redundant_updates_trigger());
-RegisterExec(1295, arrow_interval_justify_days());
-RegisterExec(1299, arrow_now());
-RegisterExec(2647, arrow_now());
-RegisterExec(1304, arrow_overlaps_timestamp());
-RegisterExec(2041, arrow_overlaps_timestamp());
-RegisterExec(1312, arrow_timestamp_in());
-RegisterExec(1313, arrow_timestamp_out());
-RegisterExec(1314, arrow_timestamp_cmp());
-RegisterExec(2045, arrow_timestamp_cmp());
-RegisterExec(1315, arrow_interval_cmp());
-RegisterExec(1326, arrow_interval_div());
-RegisterExec(1364, arrow_textregexeq_support());
-RegisterExec(1376, arrow_numeric_fac());
-RegisterExec(1389, arrow_timestamp_finite());
-RegisterExec(2048, arrow_timestamp_finite());
-RegisterExec(1390, arrow_interval_finite());
-RegisterExec(1564, arrow_bit_in());
-RegisterExec(1565, arrow_bit_out());
-RegisterExec(1579, arrow_varbit_in());
-RegisterExec(1580, arrow_varbit_out());
-RegisterExec(1581, arrow_biteq());
-RegisterExec(1666, arrow_biteq());
-RegisterExec(1582, arrow_bitne());
-RegisterExec(1667, arrow_bitne());
-RegisterExec(1592, arrow_bitge());
-RegisterExec(1668, arrow_bitge());
-RegisterExec(1593, arrow_bitgt());
-RegisterExec(1669, arrow_bitgt());
-RegisterExec(1594, arrow_bitle());
-RegisterExec(1670, arrow_bitle());
-RegisterExec(1595, arrow_bitlt());
-RegisterExec(1671, arrow_bitlt());
-RegisterExec(1596, arrow_bitcmp());
-RegisterExec(1672, arrow_bitcmp());
-RegisterExec(1618, arrow_interval_mul());
-RegisterExec(1624, arrow_mul_d_interval());
-RegisterExec(1673, arrow_bit_and());
-RegisterExec(1674, arrow_bit_or());
-RegisterExec(1675, arrow_bitxor());
-RegisterExec(1676, arrow_bitnot());
-RegisterExec(1677, arrow_bitshiftleft());
-RegisterExec(1678, arrow_bitshiftright());
-RegisterExec(1679, arrow_bitcat());
-RegisterExec(1680, arrow_bitsubstr());
-RegisterExec(1681, arrow_bitlength());
-RegisterExec(1682, arrow_bitoctetlength());
-RegisterExec(1683, arrow_bitfromint4());
-RegisterExec(1684, arrow_bittoint4());
-RegisterExec(1685, arrow_bit());
-RegisterExec(1687, arrow_varbit());
+RegisterExec(1245, arrow_charin());
+RegisterExec(1246, arrow_charlt());
+RegisterExec(1252, arrow_nameregexne());
+RegisterExec(1254, arrow_textregexeq());
+RegisterExec(1658, arrow_textregexeq());
+RegisterExec(1256, arrow_textregexne());
+RegisterExec(1659, arrow_textregexne());
+RegisterExec(1264, arrow_PG_char_to_encoding());
+RegisterExec(1267, arrow_cidr_in());
+RegisterExec(1349, arrow_oidvectortypes());
+RegisterExec(1362, arrow_network_hostmask());
+RegisterExec(1427, arrow_cidr_out());
+RegisterExec(1597, arrow_PG_encoding_to_char());
+RegisterExec(1620, arrow_ascii());
+RegisterExec(1621, arrow_chr());
+RegisterExec(1622, arrow_repeat());
+RegisterExec(1623, arrow_similar_escape());
+RegisterExec(1633, arrow_texticlike());
+RegisterExec(1660, arrow_texticlike());
+RegisterExec(1634, arrow_texticnlike());
+RegisterExec(1661, arrow_texticnlike());
+RegisterExec(1635, arrow_nameiclike());
+RegisterExec(1636, arrow_nameicnlike());
+RegisterExec(1637, arrow_like_escape());
+RegisterExec(1638, arrow_oidgt());
+RegisterExec(1639, arrow_oidge());
 RegisterExec(1691, arrow_boolle());
 RegisterExec(1692, arrow_boolge());
-RegisterExec(1697, arrow_interval_hash());
-RegisterExec(1698, arrow_bitposition());
-RegisterExec(1699, arrow_bitsubstr_no_len());
-RegisterExec(1701, arrow_numeric_in());
-RegisterExec(1702, arrow_numeric_out());
-RegisterExec(1703, arrow_numeric());
-RegisterExec(1704, arrow_numeric_abs());
-RegisterExec(1705, arrow_numeric_abs());
-RegisterExec(1706, arrow_numeric_sign());
-RegisterExec(1707, arrow_numeric_round());
-RegisterExec(1709, arrow_numeric_trunc());
-RegisterExec(1711, arrow_numeric_ceil());
-RegisterExec(2167, arrow_numeric_ceil());
-RegisterExec(1712, arrow_numeric_floor());
-RegisterExec(1718, arrow_numeric_eq());
-RegisterExec(1719, arrow_numeric_ne());
-RegisterExec(1720, arrow_numeric_gt());
-RegisterExec(1721, arrow_numeric_ge());
-RegisterExec(1722, arrow_numeric_lt());
-RegisterExec(1723, arrow_numeric_le());
-RegisterExec(1724, arrow_numeric_add());
-RegisterExec(1725, arrow_numeric_sub());
-RegisterExec(1726, arrow_numeric_mul());
-RegisterExec(1727, arrow_numeric_div());
-RegisterExec(1728, arrow_numeric_mod());
-RegisterExec(1729, arrow_numeric_mod());
-RegisterExec(1730, arrow_numeric_sqrt());
-RegisterExec(1731, arrow_numeric_sqrt());
-RegisterExec(1732, arrow_numeric_exp());
-RegisterExec(1733, arrow_numeric_exp());
-RegisterExec(1734, arrow_numeric_ln());
-RegisterExec(1735, arrow_numeric_ln());
-RegisterExec(1736, arrow_numeric_log());
-RegisterExec(1737, arrow_numeric_log());
-RegisterExec(1738, arrow_numeric_power());
-RegisterExec(1739, arrow_numeric_power());
-RegisterExec(2169, arrow_numeric_power());
-RegisterExec(1740, arrow_int4_numeric());
-RegisterExec(1742, arrow_float4_numeric());
-RegisterExec(1743, arrow_float8_numeric());
-RegisterExec(1744, arrow_numeric_int4());
-RegisterExec(1745, arrow_numeric_float4());
-RegisterExec(1746, arrow_numeric_float8());
-RegisterExec(1764, arrow_numeric_inc());
-RegisterExec(1766, arrow_numeric_smaller());
-RegisterExec(1767, arrow_numeric_larger());
-RegisterExec(1769, arrow_numeric_cmp());
-RegisterExec(1771, arrow_numeric_uminus());
-RegisterExec(1779, arrow_numeric_int8());
-RegisterExec(1781, arrow_int8_numeric());
-RegisterExec(1782, arrow_int2_numeric());
-RegisterExec(1783, arrow_numeric_int2());
-RegisterExec(1814, arrow_iclikesel());
-RegisterExec(1815, arrow_icnlikesel());
-RegisterExec(1816, arrow_iclikejoinsel());
-RegisterExec(1817, arrow_icnlikejoinsel());
-RegisterExec(1818, arrow_regexeqsel());
-RegisterExec(1819, arrow_likesel());
-RegisterExec(1820, arrow_icregexeqsel());
-RegisterExec(1821, arrow_regexnesel());
-RegisterExec(1822, arrow_nlikesel());
-RegisterExec(1823, arrow_icregexnesel());
-RegisterExec(1824, arrow_regexeqjoinsel());
-RegisterExec(1825, arrow_likejoinsel());
-RegisterExec(1826, arrow_icregexeqjoinsel());
-RegisterExec(1827, arrow_regexnejoinsel());
-RegisterExec(1828, arrow_nlikejoinsel());
-RegisterExec(1829, arrow_icregexnejoinsel());
-RegisterExec(1833, arrow_numeric_accum());
-RegisterExec(1834, arrow_int2_accum());
-RegisterExec(1835, arrow_int4_accum());
-RegisterExec(1836, arrow_int8_accum());
-RegisterExec(1837, arrow_numeric_avg());
-RegisterExec(1838, arrow_numeric_var_samp());
-RegisterExec(1839, arrow_numeric_stddev_samp());
-RegisterExec(1840, arrow_int2_sum());
-RegisterExec(1841, arrow_int4_sum());
-RegisterExec(1842, arrow_int8_sum());
-RegisterExec(1843, arrow_interval_accum());
-RegisterExec(1844, arrow_interval_avg());
-RegisterExec(1845, arrow_to_ascii_default());
-RegisterExec(1846, arrow_to_ascii_enc());
-RegisterExec(1847, arrow_to_ascii_encname());
-RegisterExec(1892, arrow_int2and());
-RegisterExec(1893, arrow_int2or());
-RegisterExec(1894, arrow_int2xor());
-RegisterExec(1895, arrow_int2not());
-RegisterExec(1896, arrow_int2shl());
-RegisterExec(1897, arrow_int2shr());
-RegisterExec(1898, arrow_int4and());
-RegisterExec(1899, arrow_int4or());
-RegisterExec(1900, arrow_int4xor());
-RegisterExec(1901, arrow_int4not());
-RegisterExec(1902, arrow_int4shl());
-RegisterExec(1903, arrow_int4shr());
-RegisterExec(1911, arrow_int2up());
-RegisterExec(1912, arrow_int4up());
-RegisterExec(1915, arrow_numeric_uplus());
-RegisterExec(1961, arrow_timestamp_scale());
-RegisterExec(1962, arrow_int2_avg_accum());
-RegisterExec(1963, arrow_int4_avg_accum());
-RegisterExec(1964, arrow_int8_avg());
-RegisterExec(1967, arrow_timestamptz_scale());
-RegisterExec(1973, arrow_numeric_div_trunc());
-RegisterExec(1980, arrow_numeric_div_trunc());
-RegisterExec(2020, arrow_timestamp_trunc());
-RegisterExec(2021, arrow_timestamp_part());
-RegisterExec(2023, arrow_jsonb_path_query_first_tz());
-RegisterExec(2027, arrow_timestamptz_timestamp());
-RegisterExec(2028, arrow_timestamp_timestamptz());
-RegisterExec(2030, arrow_jsonb_path_match_tz());
-RegisterExec(2032, arrow_timestamp_pl_interval());
-RegisterExec(2033, arrow_timestamp_mi_interval());
-RegisterExec(2034, arrow_pg_conf_load_time());
-RegisterExec(2039, arrow_timestamp_hash());
-RegisterExec(2058, arrow_timestamp_age());
-RegisterExec(2069, arrow_timestamp_zone());
-RegisterExec(2070, arrow_timestamp_izone());
-RegisterExec(2075, arrow_bitfromint8());
-RegisterExec(2076, arrow_bittoint8());
+RegisterExec(1693, arrow_btboolcmp());
+RegisterExec(1713, arrow_length_in_encoding());
+RegisterExec(1714, arrow_pg_convert_from());
+RegisterExec(1715, arrow_inet_to_cidr());
+RegisterExec(1717, arrow_pg_convert_to());
+RegisterExec(1798, arrow_oidin());
+RegisterExec(1799, arrow_oidout());
+RegisterExec(1813, arrow_pg_convert());
+RegisterExec(1965, arrow_oidlarger());
+RegisterExec(1966, arrow_oidsmaller());
+RegisterExec(1986, arrow_similar_to_escape_2());
+RegisterExec(1987, arrow_similar_to_escape_1());
+RegisterExec(2005, arrow_bytealike());
+RegisterExec(2007, arrow_bytealike());
+RegisterExec(2006, arrow_byteanlike());
+RegisterExec(2008, arrow_byteanlike());
+RegisterExec(2009, arrow_like_escape_bytea());
+RegisterExec(2015, arrow_byteatrim());
+RegisterExec(2073, arrow_textregexsubstr());
+RegisterExec(2077, arrow_show_config_by_name());
+RegisterExec(2078, arrow_set_config_by_name());
 RegisterExec(2096, arrow_pg_terminate_backend());
-RegisterExec(2170, arrow_width_bucket_numeric());
 RegisterExec(2171, arrow_pg_cancel_backend());
-RegisterExec(2292, arrow_cstring_in());
-RegisterExec(2293, arrow_cstring_out());
-RegisterExec(2294, arrow_any_in());
-RegisterExec(2295, arrow_any_out());
-RegisterExec(2296, arrow_anyarray_in());
-RegisterExec(2297, arrow_anyarray_out());
-RegisterExec(2298, arrow_void_in());
-RegisterExec(2299, arrow_void_out());
-RegisterExec(2300, arrow_trigger_in());
-RegisterExec(2301, arrow_trigger_out());
-RegisterExec(2302, arrow_language_handler_in());
-RegisterExec(2303, arrow_language_handler_out());
-RegisterExec(2304, arrow_internal_in());
-RegisterExec(2305, arrow_internal_out());
-RegisterExec(2312, arrow_anyelement_in());
-RegisterExec(2313, arrow_anyelement_out());
-RegisterExec(2398, arrow_shell_in());
-RegisterExec(2399, arrow_shell_out());
-RegisterExec(2404, arrow_int2recv());
-RegisterExec(2405, arrow_int2send());
-RegisterExec(2406, arrow_int4recv());
-RegisterExec(2407, arrow_int4send());
-RegisterExec(2410, arrow_int2vectorrecv());
-RegisterExec(2411, arrow_int2vectorsend());
+RegisterExec(2188, arrow_btint48cmp());
+RegisterExec(2189, arrow_btint84cmp());
+RegisterExec(2190, arrow_btint24cmp());
+RegisterExec(2191, arrow_btint42cmp());
+RegisterExec(2192, arrow_btint28cmp());
+RegisterExec(2193, arrow_btint82cmp());
+RegisterExec(2196, arrow_inet_client_addr());
+RegisterExec(2197, arrow_inet_client_port());
+RegisterExec(2198, arrow_inet_server_addr());
+RegisterExec(2199, arrow_inet_server_port());
+RegisterExec(2246, arrow_fmgr_internal_validator());
+RegisterExec(2247, arrow_fmgr_c_validator());
+RegisterExec(2248, arrow_fmgr_sql_validator());
+RegisterExec(2284, arrow_textregexreplace_noopt());
+RegisterExec(2285, arrow_textregexreplace());
+RegisterExec(2319, arrow_pg_encoding_max_length_sql());
+RegisterExec(2418, arrow_oidrecv());
+RegisterExec(2419, arrow_oidsend());
+RegisterExec(2420, arrow_oidvectorrecv());
+RegisterExec(2421, arrow_oidvectorsend());
+RegisterExec(2434, arrow_charrecv());
+RegisterExec(2435, arrow_charsend());
 RegisterExec(2436, arrow_boolrecv());
 RegisterExec(2437, arrow_boolsend());
-RegisterExec(2456, arrow_bit_recv());
-RegisterExec(2457, arrow_bit_send());
-RegisterExec(2458, arrow_varbit_recv());
-RegisterExec(2459, arrow_varbit_send());
-RegisterExec(2460, arrow_numeric_recv());
-RegisterExec(2461, arrow_numeric_send());
-RegisterExec(2474, arrow_timestamp_recv());
-RegisterExec(2475, arrow_timestamp_send());
-RegisterExec(2476, arrow_timestamptz_recv());
-RegisterExec(2477, arrow_timestamptz_send());
-RegisterExec(2478, arrow_interval_recv());
-RegisterExec(2479, arrow_interval_send());
-RegisterExec(2494, arrow_macaddr_recv());
-RegisterExec(2495, arrow_macaddr_send());
-RegisterExec(2500, arrow_cstring_recv());
-RegisterExec(2501, arrow_cstring_send());
-RegisterExec(2502, arrow_anyarray_recv());
-RegisterExec(2503, arrow_anyarray_send());
-RegisterExec(2514, arrow_numeric_var_pop());
+RegisterExec(2496, arrow_inet_recv());
+RegisterExec(2497, arrow_inet_send());
+RegisterExec(2498, arrow_cidr_recv());
+RegisterExec(2499, arrow_cidr_send());
 RegisterExec(2515, arrow_booland_statefunc());
 RegisterExec(2516, arrow_boolor_statefunc());
-RegisterExec(2520, arrow_timestamp_lt_timestamptz());
-RegisterExec(2521, arrow_timestamp_le_timestamptz());
-RegisterExec(2522, arrow_timestamp_eq_timestamptz());
-RegisterExec(2523, arrow_timestamp_gt_timestamptz());
-RegisterExec(2524, arrow_timestamp_ge_timestamptz());
-RegisterExec(2525, arrow_timestamp_ne_timestamptz());
-RegisterExec(2526, arrow_timestamp_cmp_timestamptz());
-RegisterExec(2527, arrow_timestamptz_lt_timestamp());
-RegisterExec(2528, arrow_timestamptz_le_timestamp());
-RegisterExec(2529, arrow_timestamptz_eq_timestamp());
-RegisterExec(2530, arrow_timestamptz_gt_timestamp());
-RegisterExec(2531, arrow_timestamptz_ge_timestamp());
-RegisterExec(2532, arrow_timestamptz_ne_timestamp());
-RegisterExec(2533, arrow_timestamptz_cmp_timestamp());
-RegisterExec(2557, arrow_int4_bool());
-RegisterExec(2558, arrow_bool_int4());
-RegisterExec(2560, arrow_pg_postmaster_start_time());
-RegisterExec(2596, arrow_numeric_stddev_pop());
+RegisterExec(2580, arrow_jsonb_float8());
 RegisterExec(2621, arrow_pg_reload_conf());
 RegisterExec(2622, arrow_pg_rotate_logfile_v2());
-RegisterExec(2648, arrow_statement_timestamp());
-RegisterExec(2649, arrow_clock_timestamp());
-RegisterExec(2711, arrow_interval_justify_interval());
-RegisterExec(2740, arrow_numeric_avg_serialize());
-RegisterExec(2741, arrow_numeric_avg_deserialize());
-RegisterExec(2746, arrow_int8_avg_accum());
-RegisterExec(2777, arrow_anynonarray_in());
-RegisterExec(2778, arrow_anynonarray_out());
-RegisterExec(2785, arrow_int8_avg_combine());
-RegisterExec(2786, arrow_int8_avg_serialize());
-RegisterExec(2787, arrow_int8_avg_deserialize());
-RegisterExec(2858, arrow_numeric_avg_accum());
-RegisterExec(2902, arrow_varbittypmodin());
-RegisterExec(2903, arrow_intervaltypmodin());
-RegisterExec(2904, arrow_intervaltypmodout());
-RegisterExec(2905, arrow_timestamptypmodin());
-RegisterExec(2906, arrow_timestamptypmodout());
-RegisterExec(2907, arrow_timestamptztypmodin());
-RegisterExec(2908, arrow_timestamptztypmodout());
-RegisterExec(2917, arrow_numerictypmodin());
-RegisterExec(2918, arrow_numerictypmodout());
-RegisterExec(2919, arrow_bittypmodin());
-RegisterExec(2920, arrow_bittypmodout());
-RegisterExec(2921, arrow_varbittypmodout());
-RegisterExec(2939, arrow_pg_snapshot_in());
-RegisterExec(5055, arrow_pg_snapshot_in());
-RegisterExec(2940, arrow_pg_snapshot_out());
-RegisterExec(5056, arrow_pg_snapshot_out());
-RegisterExec(2941, arrow_pg_snapshot_recv());
-RegisterExec(5057, arrow_pg_snapshot_recv());
-RegisterExec(2942, arrow_pg_snapshot_send());
-RegisterExec(5058, arrow_pg_snapshot_send());
-RegisterExec(2943, arrow_pg_current_xact_id());
-RegisterExec(5059, arrow_pg_current_xact_id());
-RegisterExec(2944, arrow_pg_current_snapshot());
-RegisterExec(5061, arrow_pg_current_snapshot());
-RegisterExec(2945, arrow_pg_snapshot_xmin());
-RegisterExec(5062, arrow_pg_snapshot_xmin());
-RegisterExec(2946, arrow_pg_snapshot_xmax());
-RegisterExec(5063, arrow_pg_snapshot_xmax());
-RegisterExec(2948, arrow_pg_visible_in_snapshot());
-RegisterExec(5065, arrow_pg_visible_in_snapshot());
+RegisterExec(2627, arrow_inetnot());
+RegisterExec(2628, arrow_inetand());
+RegisterExec(2629, arrow_inetor());
+RegisterExec(2630, arrow_inetpl());
+RegisterExec(2632, arrow_inetmi_int8());
+RegisterExec(2633, arrow_inetmi());
+RegisterExec(2767, arrow_regexp_split_to_array_no_flags());
+RegisterExec(2768, arrow_regexp_split_to_array());
+RegisterExec(2952, arrow_uuid_in());
+RegisterExec(2953, arrow_uuid_out());
+RegisterExec(2954, arrow_uuid_lt());
+RegisterExec(2955, arrow_uuid_le());
+RegisterExec(2956, arrow_uuid_eq());
+RegisterExec(2957, arrow_uuid_ge());
+RegisterExec(2958, arrow_uuid_gt());
+RegisterExec(2959, arrow_uuid_ne());
+RegisterExec(2960, arrow_uuid_cmp());
+RegisterExec(2961, arrow_uuid_recv());
+RegisterExec(2962, arrow_uuid_send());
+RegisterExec(2963, arrow_uuid_hash());
 RegisterExec(2971, arrow_booltext());
-RegisterExec(3030, arrow_bitoverlay());
-RegisterExec(3031, arrow_bitoverlay_no_len());
-RegisterExec(3032, arrow_bitgetbit());
-RegisterExec(3033, arrow_bitsetbit());
-RegisterExec(3116, arrow_fdw_handler_in());
-RegisterExec(3117, arrow_fdw_handler_out());
-RegisterExec(3120, arrow_void_recv());
-RegisterExec(3121, arrow_void_send());
-RegisterExec(3137, arrow_timestamp_sortsupport());
-RegisterExec(3144, arrow_macaddr_not());
-RegisterExec(3145, arrow_macaddr_and());
-RegisterExec(3146, arrow_macaddr_or());
-RegisterExec(3157, arrow_numeric_support());
-RegisterExec(3158, arrow_varbit_support());
+RegisterExec(3129, arrow_btint2sortsupport());
+RegisterExec(3130, arrow_btint4sortsupport());
+RegisterExec(3131, arrow_btint8sortsupport());
+RegisterExec(3134, arrow_btoidsortsupport());
+RegisterExec(3153, arrow_array_to_json());
+RegisterExec(3154, arrow_array_to_json_pretty());
+RegisterExec(3155, arrow_row_to_json());
+RegisterExec(3156, arrow_row_to_json_pretty());
 RegisterExec(3170, arrow_be_lo_lseek64());
 RegisterExec(3171, arrow_be_lo_tell64());
 RegisterExec(3172, arrow_be_lo_truncate64());
-RegisterExec(3178, arrow_numeric_sum());
-RegisterExec(3281, arrow_numeric_scale());
-RegisterExec(3283, arrow_numeric_sortsupport());
-RegisterExec(3311, arrow_tsm_handler_in());
-RegisterExec(3312, arrow_tsm_handler_out());
-RegisterExec(3317, arrow_pg_stat_get_wal_receiver());
-RegisterExec(3324, arrow_int4_avg_combine());
-RegisterExec(3325, arrow_interval_combine());
-RegisterExec(3335, arrow_numeric_serialize());
-RegisterExec(3336, arrow_numeric_deserialize());
-RegisterExec(3337, arrow_numeric_avg_combine());
-RegisterExec(3338, arrow_numeric_poly_combine());
-RegisterExec(3339, arrow_numeric_poly_serialize());
-RegisterExec(3340, arrow_numeric_poly_deserialize());
-RegisterExec(3341, arrow_numeric_combine());
-RegisterExec(3348, arrow_pg_current_xact_id_if_assigned());
-RegisterExec(5060, arrow_pg_current_xact_id_if_assigned());
-RegisterExec(3359, arrow_macaddr_sortsupport());
-RegisterExec(3360, arrow_pg_xact_status());
-RegisterExec(5066, arrow_pg_xact_status());
-RegisterExec(3382, arrow_pg_identify_object_as_address());
-RegisterExec(3387, arrow_int8_avg_accum_inv());
-RegisterExec(3388, arrow_numeric_poly_sum());
-RegisterExec(3389, arrow_numeric_poly_avg());
-RegisterExec(3390, arrow_numeric_poly_var_pop());
-RegisterExec(3391, arrow_numeric_poly_var_samp());
-RegisterExec(3392, arrow_numeric_poly_stddev_pop());
-RegisterExec(3393, arrow_numeric_poly_stddev_samp());
-RegisterExec(3404, arrow_pg_dependencies_in());
-RegisterExec(3405, arrow_pg_dependencies_out());
-RegisterExec(3406, arrow_pg_dependencies_recv());
-RegisterExec(3407, arrow_pg_dependencies_send());
-RegisterExec(3411, arrow_timestamp_hash_extended());
-RegisterExec(3418, arrow_interval_hash_extended());
+RegisterExec(3173, arrow_json_agg_transfn());
+RegisterExec(3174, arrow_json_agg_finalfn());
+RegisterExec(3176, arrow_to_json());
+RegisterExec(3180, arrow_json_object_agg_transfn());
+RegisterExec(3196, arrow_json_object_agg_finalfn());
+RegisterExec(3199, arrow_json_build_array_noargs());
+RegisterExec(3201, arrow_json_build_object_noargs());
+RegisterExec(3202, arrow_json_object());
+RegisterExec(3203, arrow_json_object_two_arg());
+RegisterExec(3204, arrow_json_to_record());
+RegisterExec(3207, arrow_jsonb_array_length());
+RegisterExec(3209, arrow_jsonb_populate_record());
+RegisterExec(3210, arrow_jsonb_typeof());
+RegisterExec(3214, arrow_jsonb_object_field_text());
+RegisterExec(3215, arrow_jsonb_array_element());
+RegisterExec(3216, arrow_jsonb_array_element_text());
+RegisterExec(3261, arrow_json_strip_nulls());
+RegisterExec(3262, arrow_jsonb_strip_nulls());
+RegisterExec(3263, arrow_jsonb_object());
+RegisterExec(3264, arrow_jsonb_object_two_arg());
+RegisterExec(3265, arrow_jsonb_agg_transfn());
+RegisterExec(3266, arrow_jsonb_agg_finalfn());
+RegisterExec(3268, arrow_jsonb_object_agg_transfn());
+RegisterExec(3269, arrow_jsonb_object_agg_finalfn());
+RegisterExec(3272, arrow_jsonb_build_array_noargs());
+RegisterExec(3274, arrow_jsonb_build_object_noargs());
+RegisterExec(3294, arrow_show_config_by_name_missing_ok());
+RegisterExec(3300, arrow_uuid_sortsupport());
+RegisterExec(3301, arrow_jsonb_concat());
+RegisterExec(3302, arrow_jsonb_delete());
+RegisterExec(3303, arrow_jsonb_delete_idx());
+RegisterExec(3304, arrow_jsonb_delete_path());
+RegisterExec(3305, arrow_jsonb_set());
+RegisterExec(3306, arrow_jsonb_pretty());
+RegisterExec(3355, arrow_pg_ndistinct_in());
+RegisterExec(3356, arrow_pg_ndistinct_out());
+RegisterExec(3357, arrow_pg_ndistinct_recv());
+RegisterExec(3358, arrow_pg_ndistinct_send());
+RegisterExec(3396, arrow_regexp_match_no_flags());
+RegisterExec(3397, arrow_regexp_match());
+RegisterExec(3412, arrow_uuid_hash_extended());
+RegisterExec(3414, arrow_hashenumextended());
+RegisterExec(3417, arrow_hash_range_extended());
+RegisterExec(3432, arrow_gen_random_uuid());
 RegisterExec(3434, arrow_gtsvector_options());
-RegisterExec(3437, arrow_prefixsel());
-RegisterExec(3438, arrow_prefixjoinsel());
+RegisterExec(3446, arrow_macaddr8_recv());
+RegisterExec(3447, arrow_macaddr8_send());
+RegisterExec(3449, arrow_jsonb_numeric());
+RegisterExec(3450, arrow_jsonb_int2());
+RegisterExec(3451, arrow_jsonb_int4());
+RegisterExec(3452, arrow_jsonb_int8());
+RegisterExec(3453, arrow_jsonb_float4());
 RegisterExec(3457, arrow_be_lo_from_bytea());
 RegisterExec(3458, arrow_be_lo_get());
 RegisterExec(3459, arrow_be_lo_get_fragment());
 RegisterExec(3460, arrow_be_lo_put());
-RegisterExec(3461, arrow_make_timestamp());
-RegisterExec(3462, arrow_make_timestamptz());
-RegisterExec(3463, arrow_make_timestamptz_at_timezone());
-RegisterExec(3464, arrow_make_interval());
-RegisterExec(3469, arrow_spg_range_quad_config());
-RegisterExec(3470, arrow_spg_range_quad_choose());
-RegisterExec(3471, arrow_spg_range_quad_picksplit());
-RegisterExec(3472, arrow_spg_range_quad_inner_consistent());
-RegisterExec(3473, arrow_spg_range_quad_leaf_consistent());
+RegisterExec(3478, arrow_jsonb_object_field());
+RegisterExec(3490, arrow_jsonb_to_record());
 RegisterExec(3496, arrow_bool_accum());
 RegisterExec(3497, arrow_bool_accum_inv());
 RegisterExec(3498, arrow_bool_alltrue());
 RegisterExec(3499, arrow_bool_anytrue());
-RegisterExec(3504, arrow_anyenum_in());
-RegisterExec(3505, arrow_anyenum_out());
-RegisterExec(3537, arrow_pg_describe_object());
-RegisterExec(3548, arrow_numeric_accum_inv());
-RegisterExec(3549, arrow_interval_accum_inv());
-RegisterExec(3560, arrow_networksel());
-RegisterExec(3561, arrow_networkjoinsel());
-RegisterExec(3567, arrow_int2_accum_inv());
-RegisterExec(3568, arrow_int4_accum_inv());
-RegisterExec(3569, arrow_int8_accum_inv());
-RegisterExec(3570, arrow_int2_avg_accum_inv());
-RegisterExec(3571, arrow_int4_avg_accum_inv());
-RegisterExec(3572, arrow_int2int4_sum());
-RegisterExec(3577, arrow_pg_logical_emit_message_text());
-RegisterExec(3578, arrow_pg_logical_emit_message_bytea());
-RegisterExec(3594, arrow_event_trigger_in());
-RegisterExec(3595, arrow_event_trigger_out());
+RegisterExec(3506, arrow_enum_in());
+RegisterExec(3507, arrow_enum_out());
+RegisterExec(3508, arrow_enum_eq());
+RegisterExec(3509, arrow_enum_ne());
+RegisterExec(3510, arrow_enum_lt());
+RegisterExec(3511, arrow_enum_gt());
+RegisterExec(3512, arrow_enum_le());
+RegisterExec(3513, arrow_enum_ge());
+RegisterExec(3514, arrow_enum_cmp());
+RegisterExec(3515, arrow_hashenum());
+RegisterExec(3524, arrow_enum_smaller());
+RegisterExec(3525, arrow_enum_larger());
+RegisterExec(3528, arrow_enum_first());
+RegisterExec(3529, arrow_enum_last());
+RegisterExec(3530, arrow_enum_range_bounds());
+RegisterExec(3531, arrow_enum_range_all());
+RegisterExec(3532, arrow_enum_recv());
+RegisterExec(3533, arrow_enum_send());
+RegisterExec(3551, arrow_network_overlap());
+RegisterExec(3556, arrow_jsonb_bool());
+RegisterExec(3562, arrow_network_larger());
+RegisterExec(3563, arrow_network_smaller());
+RegisterExec(3579, arrow_jsonb_insert());
+RegisterExec(3581, arrow_pg_xact_commit_timestamp());
+RegisterExec(3583, arrow_pg_last_committed_xact());
 RegisterExec(3612, arrow_tsqueryin());
 RegisterExec(3613, arrow_tsqueryout());
 RegisterExec(3640, arrow_tsquerysend());
@@ -548,106 +367,146 @@ RegisterExec(3652, arrow_gtsvector_same());
 RegisterExec(3653, arrow_gtsvector_penalty());
 RegisterExec(3654, arrow_gtsvector_consistent());
 RegisterExec(3673, arrow_tsquerytree());
-RegisterExec(3717, arrow_prsd_start());
-RegisterExec(3718, arrow_prsd_nexttoken());
-RegisterExec(3719, arrow_prsd_end());
-RegisterExec(3720, arrow_prsd_headline());
-RegisterExec(3721, arrow_prsd_lextype());
-RegisterExec(3723, arrow_ts_lexize());
-RegisterExec(3725, arrow_dsimple_init());
-RegisterExec(3726, arrow_dsimple_lexize());
-RegisterExec(3740, arrow_thesaurus_init());
-RegisterExec(3741, arrow_thesaurus_lexize());
-RegisterExec(3745, arrow_to_tsvector_byid());
-RegisterExec(3746, arrow_to_tsquery_byid());
-RegisterExec(3747, arrow_plainto_tsquery_byid());
-RegisterExec(3749, arrow_to_tsvector());
-RegisterExec(3750, arrow_to_tsquery());
-RegisterExec(3751, arrow_plainto_tsquery());
-RegisterExec(3759, arrow_get_current_ts_config());
+RegisterExec(3787, arrow_to_jsonb());
 RegisterExec(3790, arrow_gtsvector_consistent_oldsig());
+RegisterExec(3803, arrow_jsonb_send());
+RegisterExec(3804, arrow_jsonb_out());
+RegisterExec(3805, arrow_jsonb_recv());
+RegisterExec(3806, arrow_jsonb_in());
 RegisterExec(3809, arrow_pg_export_snapshot());
-RegisterExec(3832, arrow_anyrange_in());
-RegisterExec(3833, arrow_anyrange_out());
-RegisterExec(3839, arrow_pg_identify_object());
-RegisterExec(3917, arrow_timestamp_support());
-RegisterExec(3918, arrow_interval_support());
-RegisterExec(3954, arrow_pg_get_object_address());
-RegisterExec(3970, arrow_ordered_set_transition());
-RegisterExec(3973, arrow_percentile_disc_final());
-RegisterExec(3975, arrow_percentile_cont_float8_final());
-RegisterExec(3977, arrow_percentile_cont_interval_final());
-RegisterExec(3979, arrow_percentile_disc_multi_final());
-RegisterExec(3981, arrow_percentile_cont_float8_multi_final());
-RegisterExec(3983, arrow_percentile_cont_interval_multi_final());
-RegisterExec(3985, arrow_mode_final());
-RegisterExec(3994, arrow_generate_series_int4_support());
-RegisterExec(4005, arrow_jsonb_path_exists());
-RegisterExec(4007, arrow_jsonb_path_query_array());
-RegisterExec(4008, arrow_jsonb_path_query_first());
-RegisterExec(4009, arrow_jsonb_path_match());
-RegisterExec(4010, arrow_jsonb_path_exists_opr());
-RegisterExec(4011, arrow_jsonb_path_match_opr());
-RegisterExec(4018, arrow_spg_quad_config());
-RegisterExec(4019, arrow_spg_quad_choose());
-RegisterExec(4020, arrow_spg_quad_picksplit());
-RegisterExec(4021, arrow_spg_quad_inner_consistent());
-RegisterExec(4022, arrow_spg_quad_leaf_consistent());
+RegisterExec(3834, arrow_range_in());
+RegisterExec(3835, arrow_range_out());
+RegisterExec(3836, arrow_range_recv());
+RegisterExec(3837, arrow_range_send());
+RegisterExec(3840, arrow_range_constructor2());
+RegisterExec(3844, arrow_range_constructor2());
+RegisterExec(3933, arrow_range_constructor2());
+RegisterExec(3937, arrow_range_constructor2());
+RegisterExec(3941, arrow_range_constructor2());
+RegisterExec(3945, arrow_range_constructor2());
+RegisterExec(3841, arrow_range_constructor3());
+RegisterExec(3845, arrow_range_constructor3());
+RegisterExec(3934, arrow_range_constructor3());
+RegisterExec(3938, arrow_range_constructor3());
+RegisterExec(3942, arrow_range_constructor3());
+RegisterExec(3946, arrow_range_constructor3());
+RegisterExec(3848, arrow_range_lower());
+RegisterExec(3849, arrow_range_upper());
+RegisterExec(3850, arrow_range_empty());
+RegisterExec(3851, arrow_range_lower_inc());
+RegisterExec(3852, arrow_range_upper_inc());
+RegisterExec(3853, arrow_range_lower_inf());
+RegisterExec(3854, arrow_range_upper_inf());
+RegisterExec(3855, arrow_range_eq());
+RegisterExec(3856, arrow_range_ne());
+RegisterExec(3857, arrow_range_overlaps());
+RegisterExec(3858, arrow_range_contains_elem());
+RegisterExec(3859, arrow_range_contains());
+RegisterExec(3860, arrow_elem_contained_by_range());
+RegisterExec(3861, arrow_range_contained_by());
+RegisterExec(3862, arrow_range_adjacent());
+RegisterExec(3863, arrow_range_before());
+RegisterExec(3864, arrow_range_after());
+RegisterExec(3865, arrow_range_overleft());
+RegisterExec(3866, arrow_range_overright());
+RegisterExec(3867, arrow_range_union());
+RegisterExec(3868, arrow_range_intersect());
+RegisterExec(3869, arrow_range_minus());
+RegisterExec(3870, arrow_range_cmp());
+RegisterExec(3871, arrow_range_lt());
+RegisterExec(3872, arrow_range_le());
+RegisterExec(3873, arrow_range_ge());
+RegisterExec(3874, arrow_range_gt());
+RegisterExec(3902, arrow_hash_range());
+RegisterExec(3914, arrow_int4range_canonical());
+RegisterExec(3915, arrow_daterange_canonical());
+RegisterExec(3922, arrow_int4range_subdiff());
+RegisterExec(3923, arrow_int8range_subdiff());
+RegisterExec(3924, arrow_numrange_subdiff());
+RegisterExec(3925, arrow_daterange_subdiff());
+RegisterExec(3928, arrow_int8range_canonical());
+RegisterExec(3929, arrow_tsrange_subdiff());
+RegisterExec(3930, arrow_tstzrange_subdiff());
+RegisterExec(3947, arrow_json_object_field());
+RegisterExec(3948, arrow_json_object_field_text());
+RegisterExec(3949, arrow_json_array_element());
+RegisterExec(3950, arrow_json_array_element_text());
+RegisterExec(3952, arrow_brin_summarize_new_values());
+RegisterExec(3956, arrow_json_array_length());
+RegisterExec(3960, arrow_json_populate_record());
+RegisterExec(3968, arrow_json_typeof());
+RegisterExec(3999, arrow_brin_summarize_range());
+RegisterExec(4001, arrow_jsonpath_in());
+RegisterExec(4002, arrow_jsonpath_recv());
+RegisterExec(4003, arrow_jsonpath_out());
+RegisterExec(4004, arrow_jsonpath_send());
+RegisterExec(4014, arrow_brin_desummarize_range());
+RegisterExec(4057, arrow_range_merge());
+RegisterExec(4063, arrow_inet_merge());
+RegisterExec(4071, arrow_inet_same_family());
 RegisterExec(4099, arrow_pg_rotate_logfile());
-RegisterExec(4127, arrow_in_range_int4_int8());
-RegisterExec(4128, arrow_in_range_int4_int4());
-RegisterExec(4129, arrow_in_range_int4_int2());
-RegisterExec(4130, arrow_in_range_int2_int8());
-RegisterExec(4131, arrow_in_range_int2_int4());
-RegisterExec(4132, arrow_in_range_int2_int2());
-RegisterExec(4134, arrow_in_range_timestamp_interval());
-RegisterExec(4135, arrow_in_range_timestamptz_interval());
-RegisterExec(4136, arrow_in_range_interval_interval());
-RegisterExec(4141, arrow_in_range_numeric_numeric());
-RegisterExec(4209, arrow_jsonb_string_to_tsvector());
-RegisterExec(4210, arrow_json_string_to_tsvector());
-RegisterExec(4211, arrow_jsonb_string_to_tsvector_byid());
-RegisterExec(4212, arrow_json_string_to_tsvector_byid());
-RegisterExec(4213, arrow_jsonb_to_tsvector());
-RegisterExec(4214, arrow_jsonb_to_tsvector_byid());
-RegisterExec(4215, arrow_json_to_tsvector());
-RegisterExec(4216, arrow_json_to_tsvector_byid());
-RegisterExec(4226, arrow_anycompatiblemultirange_in());
-RegisterExec(4227, arrow_anycompatiblemultirange_out());
-RegisterExec(4229, arrow_anymultirange_in());
-RegisterExec(4230, arrow_anymultirange_out());
-RegisterExec(4243, arrow_multirangesel());
-RegisterExec(5001, arrow_phraseto_tsquery());
-RegisterExec(5006, arrow_phraseto_tsquery_byid());
-RegisterExec(5007, arrow_websearch_to_tsquery_byid());
-RegisterExec(5009, arrow_websearch_to_tsquery());
-RegisterExec(5010, arrow_spg_bbox_quad_config());
-RegisterExec(5011, arrow_spg_poly_quad_compress());
-RegisterExec(5012, arrow_spg_box_quad_config());
-RegisterExec(5013, arrow_spg_box_quad_choose());
-RegisterExec(5014, arrow_spg_box_quad_picksplit());
-RegisterExec(5015, arrow_spg_box_quad_inner_consistent());
-RegisterExec(5016, arrow_spg_box_quad_leaf_consistent());
-RegisterExec(5042, arrow_numeric_min_scale());
-RegisterExec(5043, arrow_numeric_trim_scale());
-RegisterExec(5044, arrow_int4gcd());
-RegisterExec(5046, arrow_int4lcm());
-RegisterExec(5048, arrow_numeric_gcd());
-RegisterExec(5049, arrow_numeric_lcm());
-RegisterExec(5086, arrow_anycompatible_in());
-RegisterExec(5087, arrow_anycompatible_out());
-RegisterExec(5088, arrow_anycompatiblearray_in());
-RegisterExec(5089, arrow_anycompatiblearray_out());
-RegisterExec(5090, arrow_anycompatiblearray_recv());
-RegisterExec(5091, arrow_anycompatiblearray_send());
-RegisterExec(5092, arrow_anycompatiblenonarray_in());
-RegisterExec(5093, arrow_anycompatiblenonarray_out());
-RegisterExec(5094, arrow_anycompatiblerange_in());
-RegisterExec(5095, arrow_anycompatiblerange_out());
-RegisterExec(6103, arrow_numeric_pg_lsn());
-RegisterExec(6162, arrow_bit_bit_count());
-RegisterExec(6177, arrow_timestamp_bin());
-RegisterExec(6178, arrow_timestamptz_bin());
-RegisterExec(6202, arrow_extract_timestamp());
-RegisterExec(6203, arrow_extract_timestamptz());
-RegisterExec(6204, arrow_extract_interval());
+RegisterExec(4110, arrow_macaddr8_in());
+RegisterExec(4111, arrow_macaddr8_out());
+RegisterExec(4112, arrow_macaddr8_trunc());
+RegisterExec(4113, arrow_macaddr8_eq());
+RegisterExec(4114, arrow_macaddr8_lt());
+RegisterExec(4115, arrow_macaddr8_le());
+RegisterExec(4116, arrow_macaddr8_gt());
+RegisterExec(4117, arrow_macaddr8_ge());
+RegisterExec(4118, arrow_macaddr8_ne());
+RegisterExec(4119, arrow_macaddr8_cmp());
+RegisterExec(4120, arrow_macaddr8_not());
+RegisterExec(4121, arrow_macaddr8_and());
+RegisterExec(4122, arrow_macaddr8_or());
+RegisterExec(4123, arrow_macaddrtomacaddr8());
+RegisterExec(4124, arrow_macaddr8tomacaddr());
+RegisterExec(4125, arrow_macaddr8_set7bit());
+RegisterExec(4401, arrow_range_intersect_agg_transfn());
+RegisterExec(4543, arrow_pg_log_backend_memory_contexts());
+RegisterExec(4616, arrow_brin_minmax_multi_opcinfo());
+RegisterExec(4617, arrow_brin_minmax_multi_add_value());
+RegisterExec(4618, arrow_brin_minmax_multi_consistent());
+RegisterExec(4619, arrow_brin_minmax_multi_union());
+RegisterExec(4620, arrow_brin_minmax_multi_options());
+RegisterExec(4621, arrow_brin_minmax_multi_distance_int2());
+RegisterExec(4622, arrow_brin_minmax_multi_distance_int4());
+RegisterExec(4623, arrow_brin_minmax_multi_distance_int8());
+RegisterExec(4624, arrow_brin_minmax_multi_distance_float4());
+RegisterExec(4625, arrow_brin_minmax_multi_distance_float8());
+RegisterExec(4626, arrow_brin_minmax_multi_distance_numeric());
+RegisterExec(4627, arrow_brin_minmax_multi_distance_tid());
+RegisterExec(4628, arrow_brin_minmax_multi_distance_uuid());
+RegisterExec(4629, arrow_brin_minmax_multi_distance_date());
+RegisterExec(4630, arrow_brin_minmax_multi_distance_time());
+RegisterExec(4631, arrow_brin_minmax_multi_distance_interval());
+RegisterExec(4632, arrow_brin_minmax_multi_distance_timetz());
+RegisterExec(4633, arrow_brin_minmax_multi_distance_pg_lsn());
+RegisterExec(4634, arrow_brin_minmax_multi_distance_macaddr());
+RegisterExec(4635, arrow_brin_minmax_multi_distance_macaddr8());
+RegisterExec(4636, arrow_brin_minmax_multi_distance_inet());
+RegisterExec(4637, arrow_brin_minmax_multi_distance_timestamp());
+RegisterExec(4638, arrow_brin_minmax_multi_summary_in());
+RegisterExec(4639, arrow_brin_minmax_multi_summary_out());
+RegisterExec(4640, arrow_brin_minmax_multi_summary_recv());
+RegisterExec(4641, arrow_brin_minmax_multi_summary_send());
+RegisterExec(5033, arrow_network_sortsupport());
+RegisterExec(5040, arrow_matchingsel());
+RegisterExec(5041, arrow_matchingjoinsel());
+RegisterExec(5054, arrow_jsonb_set_lax());
+RegisterExec(6003, arrow_pg_replication_origin_create());
+RegisterExec(6004, arrow_pg_replication_origin_drop());
+RegisterExec(6005, arrow_pg_replication_origin_oid());
+RegisterExec(6006, arrow_pg_replication_origin_session_setup());
+RegisterExec(6007, arrow_pg_replication_origin_session_reset());
+RegisterExec(6008, arrow_pg_replication_origin_session_is_setup());
+RegisterExec(6009, arrow_pg_replication_origin_session_progress());
+RegisterExec(6010, arrow_pg_replication_origin_xact_setup());
+RegisterExec(6011, arrow_pg_replication_origin_xact_reset());
+RegisterExec(6012, arrow_pg_replication_origin_advance());
+RegisterExec(6013, arrow_pg_replication_origin_progress());
+RegisterExec(6098, arrow_jsonb_subscript_handler());
+RegisterExec(6168, arrow_pg_xact_commit_timestamp_origin());
+RegisterExec(6179, arrow_array_subscript_handler());
+RegisterExec(6180, arrow_raw_array_subscript_handler());
+RegisterExec(6195, arrow_bytealtrim());
+RegisterExec(6196, arrow_byteartrim());
diff --git a/ydb/library/yql/parser/pg_wrapper/pg_kernels_register.1.inc b/ydb/library/yql/parser/pg_wrapper/pg_kernels_register.1.inc
index 09a04944dbc..aac7c60f354 100644
--- a/ydb/library/yql/parser/pg_wrapper/pg_kernels_register.1.inc
+++ b/ydb/library/yql/parser/pg_wrapper/pg_kernels_register.1.inc
@@ -1,22 +1,98 @@
-RegisterExec(34, arrow_namein());
-RegisterExec(35, arrow_nameout());
-RegisterExec(48, arrow_tidin());
-RegisterExec(49, arrow_tidout());
-RegisterExec(50, arrow_xidin());
-RegisterExec(51, arrow_xidout());
-RegisterExec(52, arrow_cidin());
-RegisterExec(53, arrow_cidout());
-RegisterExec(62, arrow_nameeq());
-RegisterExec(68, arrow_xideq());
-RegisterExec(1319, arrow_xideq());
-RegisterExec(69, arrow_cideq());
-RegisterExec(139, arrow_areasel());
-RegisterExec(140, arrow_areajoinsel());
-RegisterExec(266, arrow_nameconcatoid());
-RegisterExec(328, arrow_hashmacaddr8());
-RegisterExec(331, arrow_hashhandler());
-RegisterExec(332, arrow_gisthandler());
-RegisterExec(359, arrow_btnamecmp());
+RegisterExec(31, arrow_byteaout());
+RegisterExec(38, arrow_int2in());
+RegisterExec(39, arrow_int2out());
+RegisterExec(40, arrow_int2vectorin());
+RegisterExec(41, arrow_int2vectorout());
+RegisterExec(42, arrow_int4in());
+RegisterExec(43, arrow_int4out());
+RegisterExec(46, arrow_textin());
+RegisterExec(47, arrow_textout());
+RegisterExec(63, arrow_int2eq());
+RegisterExec(64, arrow_int2lt());
+RegisterExec(65, arrow_int4eq());
+RegisterExec(66, arrow_int4lt());
+RegisterExec(67, arrow_texteq());
+RegisterExec(109, arrow_unknownin());
+RegisterExec(110, arrow_unknownout());
+RegisterExec(141, arrow_int4mul());
+RegisterExec(144, arrow_int4ne());
+RegisterExec(145, arrow_int2ne());
+RegisterExec(146, arrow_int2gt());
+RegisterExec(147, arrow_int4gt());
+RegisterExec(148, arrow_int2le());
+RegisterExec(149, arrow_int4le());
+RegisterExec(150, arrow_int4ge());
+RegisterExec(151, arrow_int2ge());
+RegisterExec(152, arrow_int2mul());
+RegisterExec(153, arrow_int2div());
+RegisterExec(154, arrow_int4div());
+RegisterExec(155, arrow_int2mod());
+RegisterExec(940, arrow_int2mod());
+RegisterExec(156, arrow_int4mod());
+RegisterExec(941, arrow_int4mod());
+RegisterExec(157, arrow_textne());
+RegisterExec(158, arrow_int24eq());
+RegisterExec(159, arrow_int42eq());
+RegisterExec(160, arrow_int24lt());
+RegisterExec(161, arrow_int42lt());
+RegisterExec(162, arrow_int24gt());
+RegisterExec(163, arrow_int42gt());
+RegisterExec(164, arrow_int24ne());
+RegisterExec(165, arrow_int42ne());
+RegisterExec(166, arrow_int24le());
+RegisterExec(167, arrow_int42le());
+RegisterExec(168, arrow_int24ge());
+RegisterExec(169, arrow_int42ge());
+RegisterExec(170, arrow_int24mul());
+RegisterExec(171, arrow_int42mul());
+RegisterExec(172, arrow_int24div());
+RegisterExec(173, arrow_int42div());
+RegisterExec(176, arrow_int2pl());
+RegisterExec(177, arrow_int4pl());
+RegisterExec(178, arrow_int24pl());
+RegisterExec(179, arrow_int42pl());
+RegisterExec(180, arrow_int2mi());
+RegisterExec(181, arrow_int4mi());
+RegisterExec(182, arrow_int24mi());
+RegisterExec(183, arrow_int42mi());
+RegisterExec(212, arrow_int4um());
+RegisterExec(213, arrow_int2um());
+RegisterExec(240, arrow_nameeqtext());
+RegisterExec(241, arrow_namelttext());
+RegisterExec(242, arrow_nameletext());
+RegisterExec(243, arrow_namegetext());
+RegisterExec(244, arrow_namegttext());
+RegisterExec(245, arrow_namenetext());
+RegisterExec(246, arrow_btnametextcmp());
+RegisterExec(247, arrow_texteqname());
+RegisterExec(248, arrow_textltname());
+RegisterExec(249, arrow_textlename());
+RegisterExec(250, arrow_textgename());
+RegisterExec(251, arrow_textgtname());
+RegisterExec(252, arrow_textnename());
+RegisterExec(253, arrow_bttextnamecmp());
+RegisterExec(313, arrow_i2toi4());
+RegisterExec(314, arrow_i4toi2());
+RegisterExec(329, arrow_hash_aclitem());
+RegisterExec(330, arrow_bthandler());
+RegisterExec(338, arrow_amvalidate());
+RegisterExec(360, arrow_bttextcmp());
+RegisterExec(376, arrow_text_to_array_null());
+RegisterExec(382, arrow_btarraycmp());
+RegisterExec(384, arrow_array_to_text_null());
+RegisterExec(390, arrow_array_ne());
+RegisterExec(391, arrow_array_lt());
+RegisterExec(392, arrow_array_gt());
+RegisterExec(393, arrow_array_le());
+RegisterExec(394, arrow_text_to_array());
+RegisterExec(395, arrow_array_to_text());
+RegisterExec(396, arrow_array_ge());
+RegisterExec(406, arrow_name_text());
+RegisterExec(1401, arrow_name_text());
+RegisterExec(407, arrow_text_name());
+RegisterExec(1400, arrow_text_name());
+RegisterExec(458, arrow_text_larger());
+RegisterExec(459, arrow_text_smaller());
 RegisterExec(460, arrow_int8in());
 RegisterExec(461, arrow_int8out());
 RegisterExec(462, arrow_int8um());
@@ -40,37 +116,65 @@ RegisterExec(480, arrow_int84());
 RegisterExec(481, arrow_int48());
 RegisterExec(482, arrow_i8tod());
 RegisterExec(483, arrow_dtoi8());
+RegisterExec(515, arrow_array_larger());
+RegisterExec(516, arrow_array_smaller());
+RegisterExec(626, arrow_hash_array());
 RegisterExec(652, arrow_i8tof());
 RegisterExec(653, arrow_ftoi8());
-RegisterExec(655, arrow_namelt());
-RegisterExec(656, arrow_namele());
-RegisterExec(657, arrow_namegt());
-RegisterExec(658, arrow_namege());
-RegisterExec(659, arrow_namene());
-RegisterExec(710, arrow_current_user());
-RegisterExec(745, arrow_current_user());
 RegisterExec(714, arrow_int82());
-RegisterExec(746, arrow_session_user());
+RegisterExec(720, arrow_byteaoctetlen());
+RegisterExec(2010, arrow_byteaoctetlen());
+RegisterExec(721, arrow_byteaGetByte());
+RegisterExec(722, arrow_byteaSetByte());
+RegisterExec(723, arrow_byteaGetBit());
+RegisterExec(724, arrow_byteaSetBit());
+RegisterExec(740, arrow_text_lt());
+RegisterExec(741, arrow_text_le());
+RegisterExec(742, arrow_text_gt());
+RegisterExec(743, arrow_text_ge());
+RegisterExec(744, arrow_array_eq());
+RegisterExec(747, arrow_array_dims());
+RegisterExec(748, arrow_array_ndims());
+RegisterExec(749, arrow_byteaoverlay());
+RegisterExec(750, arrow_array_in());
+RegisterExec(751, arrow_array_out());
+RegisterExec(752, arrow_byteaoverlay_no_len());
 RegisterExec(754, arrow_int28());
-RegisterExec(781, arrow_hashmacaddr8extended());
-RegisterExec(817, arrow_current_query());
+RegisterExec(766, arrow_int4inc());
+RegisterExec(768, arrow_int4larger());
+RegisterExec(769, arrow_int4smaller());
+RegisterExec(770, arrow_int2larger());
+RegisterExec(771, arrow_int2smaller());
+RegisterExec(777, arrow_hash_aclitem_extended());
+RegisterExec(782, arrow_hash_array_extended());
 RegisterExec(837, arrow_int82pl());
 RegisterExec(838, arrow_int82mi());
 RegisterExec(839, arrow_int82mul());
 RegisterExec(840, arrow_int82div());
 RegisterExec(841, arrow_int28pl());
+RegisterExec(849, arrow_textpos());
+RegisterExec(868, arrow_textpos());
 RegisterExec(852, arrow_int48eq());
 RegisterExec(853, arrow_int48ne());
 RegisterExec(854, arrow_int48lt());
 RegisterExec(855, arrow_int48gt());
 RegisterExec(856, arrow_int48le());
 RegisterExec(857, arrow_int48ge());
-RegisterExec(861, arrow_current_database());
+RegisterExec(877, arrow_text_substr());
+RegisterExec(936, arrow_text_substr());
+RegisterExec(883, arrow_text_substr_no_len());
+RegisterExec(937, arrow_text_substr_no_len());
 RegisterExec(942, arrow_int28mi());
 RegisterExec(943, arrow_int28mul());
 RegisterExec(945, arrow_int8mod());
 RegisterExec(947, arrow_int8mod());
 RegisterExec(948, arrow_int28div());
+RegisterExec(1031, arrow_aclitemin());
+RegisterExec(1032, arrow_aclitemout());
+RegisterExec(1035, arrow_aclinsert());
+RegisterExec(1036, arrow_aclremove());
+RegisterExec(1037, arrow_aclcontains());
+RegisterExec(1062, arrow_aclitem_eq());
 RegisterExec(1084, arrow_date_in());
 RegisterExec(1085, arrow_date_out());
 RegisterExec(1086, arrow_date_eq());
@@ -86,7 +190,6 @@ RegisterExec(1104, arrow_time_gt());
 RegisterExec(1105, arrow_time_ge());
 RegisterExec(1106, arrow_time_ne());
 RegisterExec(1107, arrow_time_cmp());
-RegisterExec(1136, arrow_pg_stat_get_wal());
 RegisterExec(1138, arrow_date_larger());
 RegisterExec(1139, arrow_date_smaller());
 RegisterExec(1140, arrow_date_mi());
@@ -96,15 +199,27 @@ RegisterExec(1143, arrow_time_in());
 RegisterExec(1144, arrow_time_out());
 RegisterExec(1145, arrow_time_eq());
 RegisterExec(1174, arrow_date_timestamptz());
+RegisterExec(1177, arrow_jsonb_path_exists_tz());
 RegisterExec(1178, arrow_timestamptz_date());
-RegisterExec(1181, arrow_xid_age());
+RegisterExec(1180, arrow_jsonb_path_query_array_tz());
+RegisterExec(1193, arrow_array_fill());
 RegisterExec(1219, arrow_int8inc());
 RegisterExec(1230, arrow_int8abs());
 RegisterExec(1396, arrow_int8abs());
 RegisterExec(1236, arrow_int8larger());
 RegisterExec(1237, arrow_int8smaller());
-RegisterExec(1265, arrow_tidne());
-RegisterExec(1268, arrow_parse_ident());
+RegisterExec(1244, arrow_byteain());
+RegisterExec(1250, arrow_unique_key_recheck());
+RegisterExec(1251, arrow_int4abs());
+RegisterExec(1397, arrow_int4abs());
+RegisterExec(1253, arrow_int2abs());
+RegisterExec(1398, arrow_int2abs());
+RegisterExec(1257, arrow_textlen());
+RegisterExec(1317, arrow_textlen());
+RegisterExec(1369, arrow_textlen());
+RegisterExec(1381, arrow_textlen());
+RegisterExec(1258, arrow_textcat());
+RegisterExec(1269, arrow_pg_column_size());
 RegisterExec(1271, arrow_overlaps_timetz());
 RegisterExec(1272, arrow_datetime_timestamp());
 RegisterExec(2025, arrow_datetime_timestamp());
@@ -117,16 +232,11 @@ RegisterExec(1278, arrow_int48pl());
 RegisterExec(1279, arrow_int48mi());
 RegisterExec(1280, arrow_int48mul());
 RegisterExec(1281, arrow_int48div());
+RegisterExec(1286, arrow_array_fill_with_lower_bounds());
 RegisterExec(1287, arrow_i8tooid());
 RegisterExec(1288, arrow_oidtoi8());
-RegisterExec(1292, arrow_tideq());
-RegisterExec(1294, arrow_currtid_byrelname());
 RegisterExec(1297, arrow_datetimetz_timestamptz());
 RegisterExec(1359, arrow_datetimetz_timestamptz());
-RegisterExec(1300, arrow_positionsel());
-RegisterExec(1301, arrow_positionjoinsel());
-RegisterExec(1302, arrow_contsel());
-RegisterExec(1303, arrow_contjoinsel());
 RegisterExec(1308, arrow_overlaps_time());
 RegisterExec(1316, arrow_timestamp_time());
 RegisterExec(1350, arrow_timetz_in());
@@ -138,41 +248,26 @@ RegisterExec(1355, arrow_timetz_le());
 RegisterExec(1356, arrow_timetz_ge());
 RegisterExec(1357, arrow_timetz_gt());
 RegisterExec(1358, arrow_timetz_cmp());
+RegisterExec(1365, arrow_makeaclitem());
 RegisterExec(1370, arrow_time_interval());
 RegisterExec(1373, arrow_date_finite());
+RegisterExec(1374, arrow_textoctetlen());
 RegisterExec(1377, arrow_time_larger());
 RegisterExec(1378, arrow_time_smaller());
 RegisterExec(1379, arrow_timetz_larger());
 RegisterExec(1380, arrow_timetz_smaller());
 RegisterExec(1385, arrow_time_part());
-RegisterExec(1387, arrow_pg_get_constraintdef());
 RegisterExec(1388, arrow_timestamptz_timetz());
-RegisterExec(1391, arrow_pg_stat_get_backend_start());
-RegisterExec(1392, arrow_pg_stat_get_backend_client_addr());
-RegisterExec(1393, arrow_pg_stat_get_backend_client_port());
-RegisterExec(1402, arrow_current_schema());
-RegisterExec(1403, arrow_current_schemas());
+RegisterExec(1404, arrow_textoverlay());
+RegisterExec(1405, arrow_textoverlay_no_len());
 RegisterExec(1419, arrow_interval_time());
-RegisterExec(1573, arrow_pg_get_ruledef());
-RegisterExec(1574, arrow_nextval_oid());
-RegisterExec(1575, arrow_currval_oid());
-RegisterExec(1576, arrow_setval_oid());
-RegisterExec(1619, arrow_pg_typeof());
-RegisterExec(1640, arrow_pg_get_viewdef_name());
-RegisterExec(1641, arrow_pg_get_viewdef());
-RegisterExec(1642, arrow_pg_get_userbyid());
-RegisterExec(1643, arrow_pg_get_indexdef());
-RegisterExec(1662, arrow_pg_get_triggerdef());
-RegisterExec(1665, arrow_pg_get_serial_sequence());
 RegisterExec(1688, arrow_time_hash());
 RegisterExec(1690, arrow_time_mi_time());
 RegisterExec(1696, arrow_timetz_hash());
-RegisterExec(1716, arrow_pg_get_expr());
 RegisterExec(1747, arrow_time_pl_interval());
 RegisterExec(1748, arrow_time_mi_interval());
 RegisterExec(1749, arrow_timetz_pl_interval());
 RegisterExec(1750, arrow_timetz_mi_interval());
-RegisterExec(1765, arrow_setval3_oid());
 RegisterExec(1850, arrow_int28eq());
 RegisterExec(1851, arrow_int28ne());
 RegisterExec(1852, arrow_int28lt());
@@ -185,6 +280,18 @@ RegisterExec(1858, arrow_int82lt());
 RegisterExec(1859, arrow_int82gt());
 RegisterExec(1860, arrow_int82le());
 RegisterExec(1861, arrow_int82ge());
+RegisterExec(1892, arrow_int2and());
+RegisterExec(1893, arrow_int2or());
+RegisterExec(1894, arrow_int2xor());
+RegisterExec(1895, arrow_int2not());
+RegisterExec(1896, arrow_int2shl());
+RegisterExec(1897, arrow_int2shr());
+RegisterExec(1898, arrow_int4and());
+RegisterExec(1899, arrow_int4or());
+RegisterExec(1900, arrow_int4xor());
+RegisterExec(1901, arrow_int4not());
+RegisterExec(1902, arrow_int4shl());
+RegisterExec(1903, arrow_int4shr());
 RegisterExec(1904, arrow_int8and());
 RegisterExec(1905, arrow_int8or());
 RegisterExec(1906, arrow_int8xor());
@@ -192,56 +299,83 @@ RegisterExec(1907, arrow_int8not());
 RegisterExec(1908, arrow_int8shl());
 RegisterExec(1909, arrow_int8shr());
 RegisterExec(1910, arrow_int8up());
-RegisterExec(1928, arrow_pg_stat_get_numscans());
-RegisterExec(1929, arrow_pg_stat_get_tuples_returned());
-RegisterExec(1930, arrow_pg_stat_get_tuples_fetched());
-RegisterExec(1931, arrow_pg_stat_get_tuples_inserted());
-RegisterExec(1932, arrow_pg_stat_get_tuples_updated());
-RegisterExec(1933, arrow_pg_stat_get_tuples_deleted());
-RegisterExec(1934, arrow_pg_stat_get_blocks_fetched());
-RegisterExec(1935, arrow_pg_stat_get_blocks_hit());
-RegisterExec(1937, arrow_pg_stat_get_backend_pid());
-RegisterExec(1938, arrow_pg_stat_get_backend_dbid());
-RegisterExec(1939, arrow_pg_stat_get_backend_userid());
-RegisterExec(1940, arrow_pg_stat_get_backend_activity());
-RegisterExec(1941, arrow_pg_stat_get_db_numbackends());
-RegisterExec(1942, arrow_pg_stat_get_db_xact_commit());
-RegisterExec(1943, arrow_pg_stat_get_db_xact_rollback());
-RegisterExec(1944, arrow_pg_stat_get_db_blocks_fetched());
-RegisterExec(1945, arrow_pg_stat_get_db_blocks_hit());
+RegisterExec(1911, arrow_int2up());
+RegisterExec(1912, arrow_int4up());
+RegisterExec(1922, arrow_has_table_privilege_name_name());
+RegisterExec(1923, arrow_has_table_privilege_name_id());
+RegisterExec(1924, arrow_has_table_privilege_id_name());
+RegisterExec(1925, arrow_has_table_privilege_id_id());
+RegisterExec(1926, arrow_has_table_privilege_name());
+RegisterExec(1927, arrow_has_table_privilege_id());
+RegisterExec(1948, arrow_byteaeq());
+RegisterExec(1949, arrow_bytealt());
+RegisterExec(1950, arrow_byteale());
+RegisterExec(1951, arrow_byteagt());
+RegisterExec(1952, arrow_byteage());
+RegisterExec(1953, arrow_byteane());
+RegisterExec(1954, arrow_byteacmp());
 RegisterExec(1968, arrow_time_scale());
 RegisterExec(1969, arrow_timetz_scale());
-RegisterExec(1972, arrow_pg_stat_get_tuples_hot_updated());
+RegisterExec(2011, arrow_byteacat());
+RegisterExec(2012, arrow_bytea_substr());
+RegisterExec(2085, arrow_bytea_substr());
+RegisterExec(2013, arrow_bytea_substr_no_len());
+RegisterExec(2086, arrow_bytea_substr_no_len());
+RegisterExec(2014, arrow_byteapos());
 RegisterExec(2019, arrow_timestamptz_time());
+RegisterExec(2023, arrow_jsonb_path_query_first_tz());
 RegisterExec(2024, arrow_date_timestamp());
-RegisterExec(2026, arrow_pg_backend_pid());
 RegisterExec(2029, arrow_timestamp_date());
+RegisterExec(2030, arrow_jsonb_path_match_tz());
 RegisterExec(2037, arrow_timetz_zone());
 RegisterExec(2038, arrow_timetz_izone());
 RegisterExec(2046, arrow_timetz_time());
 RegisterExec(2047, arrow_time_timetz());
 RegisterExec(2071, arrow_date_pl_interval());
 RegisterExec(2072, arrow_date_mi_interval());
-RegisterExec(2094, arrow_pg_stat_get_backend_activity_start());
-RegisterExec(2098, arrow_pg_get_functiondef());
-RegisterExec(2162, arrow_pg_get_function_arguments());
-RegisterExec(2165, arrow_pg_get_function_result());
-RegisterExec(2168, arrow_pg_database_size_name());
-RegisterExec(2230, arrow_pg_stat_clear_snapshot());
-RegisterExec(2232, arrow_pg_get_function_identity_arguments());
-RegisterExec(2233, arrow_hashtid());
-RegisterExec(2234, arrow_hashtidextended());
-RegisterExec(2274, arrow_pg_stat_reset());
-RegisterExec(2286, arrow_pg_total_relation_size());
-RegisterExec(2288, arrow_pg_size_pretty());
-RegisterExec(2290, arrow_record_in());
-RegisterExec(2291, arrow_record_out());
-RegisterExec(2307, arrow_pg_stat_reset_slru());
-RegisterExec(2316, arrow_postgresql_fdw_validator());
-RegisterExec(2322, arrow_pg_tablespace_size_oid());
-RegisterExec(2323, arrow_pg_tablespace_size_name());
-RegisterExec(2324, arrow_pg_database_size_oid());
-RegisterExec(2332, arrow_pg_relation_size());
+RegisterExec(2087, arrow_replace_text());
+RegisterExec(2088, arrow_split_part());
+RegisterExec(2089, arrow_to_hex32());
+RegisterExec(2090, arrow_to_hex64());
+RegisterExec(2091, arrow_array_lower());
+RegisterExec(2092, arrow_array_upper());
+RegisterExec(2121, arrow_pg_column_compression());
+RegisterExec(2160, arrow_text_pattern_lt());
+RegisterExec(2161, arrow_text_pattern_le());
+RegisterExec(2163, arrow_text_pattern_ge());
+RegisterExec(2164, arrow_text_pattern_gt());
+RegisterExec(2166, arrow_bttext_pattern_cmp());
+RegisterExec(2176, arrow_array_length());
+RegisterExec(2181, arrow_has_sequence_privilege_name_name());
+RegisterExec(2182, arrow_has_sequence_privilege_name_id());
+RegisterExec(2183, arrow_has_sequence_privilege_id_name());
+RegisterExec(2184, arrow_has_sequence_privilege_id_id());
+RegisterExec(2185, arrow_has_sequence_privilege_name());
+RegisterExec(2186, arrow_has_sequence_privilege_id());
+RegisterExec(2250, arrow_has_database_privilege_name_name());
+RegisterExec(2251, arrow_has_database_privilege_name_id());
+RegisterExec(2252, arrow_has_database_privilege_id_name());
+RegisterExec(2253, arrow_has_database_privilege_id_id());
+RegisterExec(2254, arrow_has_database_privilege_name());
+RegisterExec(2255, arrow_has_database_privilege_id());
+RegisterExec(2256, arrow_has_function_privilege_name_name());
+RegisterExec(2257, arrow_has_function_privilege_name_id());
+RegisterExec(2258, arrow_has_function_privilege_id_name());
+RegisterExec(2259, arrow_has_function_privilege_id_id());
+RegisterExec(2260, arrow_has_function_privilege_name());
+RegisterExec(2261, arrow_has_function_privilege_id());
+RegisterExec(2262, arrow_has_language_privilege_name_name());
+RegisterExec(2263, arrow_has_language_privilege_name_id());
+RegisterExec(2264, arrow_has_language_privilege_id_name());
+RegisterExec(2265, arrow_has_language_privilege_id_id());
+RegisterExec(2266, arrow_has_language_privilege_name());
+RegisterExec(2267, arrow_has_language_privilege_id());
+RegisterExec(2268, arrow_has_schema_privilege_name_name());
+RegisterExec(2269, arrow_has_schema_privilege_name_id());
+RegisterExec(2270, arrow_has_schema_privilege_id_name());
+RegisterExec(2271, arrow_has_schema_privilege_id_id());
+RegisterExec(2272, arrow_has_schema_privilege_name());
+RegisterExec(2273, arrow_has_schema_privilege_id());
 RegisterExec(2338, arrow_date_lt_timestamp());
 RegisterExec(2339, arrow_date_le_timestamp());
 RegisterExec(2340, arrow_date_eq_timestamp());
@@ -270,157 +404,178 @@ RegisterExec(2380, arrow_timestamptz_gt_date());
 RegisterExec(2381, arrow_timestamptz_ge_date());
 RegisterExec(2382, arrow_timestamptz_ne_date());
 RegisterExec(2383, arrow_timestamptz_cmp_date());
-RegisterExec(2402, arrow_record_recv());
-RegisterExec(2403, arrow_record_send());
+RegisterExec(2390, arrow_has_tablespace_privilege_name_name());
+RegisterExec(2391, arrow_has_tablespace_privilege_name_id());
+RegisterExec(2392, arrow_has_tablespace_privilege_id_name());
+RegisterExec(2393, arrow_has_tablespace_privilege_id_id());
+RegisterExec(2394, arrow_has_tablespace_privilege_name());
+RegisterExec(2395, arrow_has_tablespace_privilege_id());
+RegisterExec(2400, arrow_array_recv());
+RegisterExec(2401, arrow_array_send());
+RegisterExec(2404, arrow_int2recv());
+RegisterExec(2405, arrow_int2send());
+RegisterExec(2406, arrow_int4recv());
+RegisterExec(2407, arrow_int4send());
 RegisterExec(2408, arrow_int8recv());
 RegisterExec(2409, arrow_int8send());
-RegisterExec(2422, arrow_namerecv());
-RegisterExec(2423, arrow_namesend());
-RegisterExec(2438, arrow_tidrecv());
-RegisterExec(2439, arrow_tidsend());
-RegisterExec(2440, arrow_xidrecv());
-RegisterExec(2441, arrow_xidsend());
-RegisterExec(2442, arrow_cidrecv());
-RegisterExec(2443, arrow_cidsend());
+RegisterExec(2410, arrow_int2vectorrecv());
+RegisterExec(2411, arrow_int2vectorsend());
+RegisterExec(2412, arrow_bytearecv());
+RegisterExec(2413, arrow_byteasend());
+RegisterExec(2414, arrow_textrecv());
+RegisterExec(2415, arrow_textsend());
+RegisterExec(2416, arrow_unknownrecv());
+RegisterExec(2417, arrow_unknownsend());
 RegisterExec(2468, arrow_date_recv());
 RegisterExec(2469, arrow_date_send());
 RegisterExec(2470, arrow_time_recv());
 RegisterExec(2471, arrow_time_send());
 RegisterExec(2472, arrow_timetz_recv());
 RegisterExec(2473, arrow_timetz_send());
-RegisterExec(2504, arrow_pg_get_ruledef_ext());
-RegisterExec(2505, arrow_pg_get_viewdef_name_ext());
-RegisterExec(2506, arrow_pg_get_viewdef_ext());
-RegisterExec(2507, arrow_pg_get_indexdef_ext());
-RegisterExec(2508, arrow_pg_get_constraintdef_ext());
-RegisterExec(2509, arrow_pg_get_expr_ext());
-RegisterExec(2559, arrow_lastval());
-RegisterExec(2623, arrow_pg_stat_file_1arg());
-RegisterExec(2624, arrow_pg_read_file_off_len());
-RegisterExec(2626, arrow_pg_sleep());
-RegisterExec(2730, arrow_pg_get_triggerdef_ext());
-RegisterExec(2758, arrow_pg_stat_get_db_tuples_returned());
-RegisterExec(2759, arrow_pg_stat_get_db_tuples_fetched());
-RegisterExec(2760, arrow_pg_stat_get_db_tuples_inserted());
-RegisterExec(2761, arrow_pg_stat_get_db_tuples_updated());
-RegisterExec(2762, arrow_pg_stat_get_db_tuples_deleted());
-RegisterExec(2769, arrow_pg_stat_get_bgwriter_timed_checkpoints());
-RegisterExec(2770, arrow_pg_stat_get_bgwriter_requested_checkpoints());
-RegisterExec(2771, arrow_pg_stat_get_bgwriter_buf_written_checkpoints());
-RegisterExec(2772, arrow_pg_stat_get_bgwriter_buf_written_clean());
-RegisterExec(2773, arrow_pg_stat_get_bgwriter_maxwritten_clean());
-RegisterExec(2775, arrow_pg_stat_get_buf_written_backend());
-RegisterExec(2781, arrow_pg_stat_get_last_vacuum_time());
-RegisterExec(2782, arrow_pg_stat_get_last_autovacuum_time());
-RegisterExec(2783, arrow_pg_stat_get_last_analyze_time());
-RegisterExec(2784, arrow_pg_stat_get_last_autoanalyze_time());
-RegisterExec(2788, arrow_pg_stat_get_backend_wait_event_type());
-RegisterExec(2790, arrow_tidgt());
-RegisterExec(2791, arrow_tidlt());
-RegisterExec(2792, arrow_tidge());
-RegisterExec(2793, arrow_tidle());
-RegisterExec(2794, arrow_bttidcmp());
-RegisterExec(2795, arrow_tidlarger());
-RegisterExec(2796, arrow_tidsmaller());
+RegisterExec(2557, arrow_int4_bool());
+RegisterExec(2558, arrow_bool_int4());
+RegisterExec(2561, arrow_pg_blocking_pids());
+RegisterExec(2614, arrow_xmlexists());
+RegisterExec(2700, arrow_gin_cmp_prefix());
+RegisterExec(2705, arrow_pg_has_role_name_name());
+RegisterExec(2706, arrow_pg_has_role_name_id());
+RegisterExec(2707, arrow_pg_has_role_id_name());
+RegisterExec(2708, arrow_pg_has_role_id_id());
+RegisterExec(2709, arrow_pg_has_role_name());
+RegisterExec(2710, arrow_pg_has_role_id());
+RegisterExec(2747, arrow_arrayoverlap());
+RegisterExec(2748, arrow_arraycontains());
+RegisterExec(2749, arrow_arraycontained());
 RegisterExec(2804, arrow_int8inc_any());
 RegisterExec(2805, arrow_int8inc_float8_float8());
-RegisterExec(2844, arrow_pg_stat_get_db_blk_read_time());
-RegisterExec(2845, arrow_pg_stat_get_db_blk_write_time());
-RegisterExec(2853, arrow_pg_stat_get_backend_wait_event());
-RegisterExec(2857, arrow_pg_stat_get_backend_xact_start());
-RegisterExec(2859, arrow_pg_stat_get_buf_alloc());
-RegisterExec(2878, arrow_pg_stat_get_live_tuples());
-RegisterExec(2879, arrow_pg_stat_get_dead_tuples());
+RegisterExec(2880, arrow_pg_advisory_lock_int8());
+RegisterExec(2881, arrow_pg_advisory_lock_shared_int8());
+RegisterExec(2882, arrow_pg_try_advisory_lock_int8());
+RegisterExec(2883, arrow_pg_try_advisory_lock_shared_int8());
+RegisterExec(2884, arrow_pg_advisory_unlock_int8());
+RegisterExec(2885, arrow_pg_advisory_unlock_shared_int8());
+RegisterExec(2886, arrow_pg_advisory_lock_int4());
+RegisterExec(2887, arrow_pg_advisory_lock_shared_int4());
+RegisterExec(2888, arrow_pg_try_advisory_lock_int4());
+RegisterExec(2889, arrow_pg_try_advisory_lock_shared_int4());
+RegisterExec(2890, arrow_pg_advisory_unlock_int4());
+RegisterExec(2891, arrow_pg_advisory_unlock_shared_int4());
+RegisterExec(2892, arrow_pg_advisory_unlock_all());
+RegisterExec(2893, arrow_xml_in());
+RegisterExec(2894, arrow_xml_out());
+RegisterExec(2895, arrow_xmlcomment());
+RegisterExec(2896, arrow_texttoxml());
+RegisterExec(2897, arrow_xmlvalidate());
+RegisterExec(2898, arrow_xml_recv());
+RegisterExec(2899, arrow_xml_send());
+RegisterExec(2900, arrow_xmlconcat2());
 RegisterExec(2909, arrow_timetypmodin());
 RegisterExec(2910, arrow_timetypmodout());
 RegisterExec(2911, arrow_timetztypmodin());
 RegisterExec(2912, arrow_timetztypmodout());
-RegisterExec(2978, arrow_pg_stat_get_function_calls());
-RegisterExec(2979, arrow_pg_stat_get_function_total_time());
-RegisterExec(2980, arrow_pg_stat_get_function_self_time());
-RegisterExec(2981, arrow_record_eq());
-RegisterExec(2982, arrow_record_ne());
-RegisterExec(2983, arrow_record_lt());
-RegisterExec(2984, arrow_record_gt());
-RegisterExec(2985, arrow_record_le());
-RegisterExec(2986, arrow_record_ge());
-RegisterExec(2987, arrow_btrecordcmp());
-RegisterExec(2997, arrow_pg_table_size());
-RegisterExec(2998, arrow_pg_indexes_size());
-RegisterExec(2999, arrow_pg_relation_filenode());
-RegisterExec(3034, arrow_pg_relation_filepath());
-RegisterExec(3037, arrow_pg_stat_get_xact_numscans());
-RegisterExec(3038, arrow_pg_stat_get_xact_tuples_returned());
-RegisterExec(3039, arrow_pg_stat_get_xact_tuples_fetched());
-RegisterExec(3040, arrow_pg_stat_get_xact_tuples_inserted());
-RegisterExec(3041, arrow_pg_stat_get_xact_tuples_updated());
-RegisterExec(3042, arrow_pg_stat_get_xact_tuples_deleted());
-RegisterExec(3043, arrow_pg_stat_get_xact_tuples_hot_updated());
-RegisterExec(3044, arrow_pg_stat_get_xact_blocks_fetched());
-RegisterExec(3045, arrow_pg_stat_get_xact_blocks_hit());
-RegisterExec(3046, arrow_pg_stat_get_xact_function_calls());
-RegisterExec(3047, arrow_pg_stat_get_xact_function_total_time());
-RegisterExec(3048, arrow_pg_stat_get_xact_function_self_time());
-RegisterExec(3054, arrow_pg_stat_get_vacuum_count());
-RegisterExec(3055, arrow_pg_stat_get_autovacuum_count());
-RegisterExec(3056, arrow_pg_stat_get_analyze_count());
-RegisterExec(3057, arrow_pg_stat_get_autoanalyze_count());
-RegisterExec(3063, arrow_pg_stat_get_buf_fsync_backend());
-RegisterExec(3065, arrow_pg_stat_get_db_conflict_tablespace());
-RegisterExec(3066, arrow_pg_stat_get_db_conflict_lock());
-RegisterExec(3067, arrow_pg_stat_get_db_conflict_snapshot());
-RegisterExec(3068, arrow_pg_stat_get_db_conflict_bufferpin());
-RegisterExec(3069, arrow_pg_stat_get_db_conflict_startup_deadlock());
-RegisterExec(3070, arrow_pg_stat_get_db_conflict_all());
-RegisterExec(3074, arrow_pg_stat_get_db_stat_reset_time());
-RegisterExec(3075, arrow_pg_stat_get_bgwriter_stat_reset_time());
-RegisterExec(3078, arrow_pg_sequence_parameters());
-RegisterExec(3135, arrow_btnamesortsupport());
+RegisterExec(2922, arrow_xmltotext());
+RegisterExec(2923, arrow_table_to_xml());
+RegisterExec(2924, arrow_query_to_xml());
+RegisterExec(2925, arrow_cursor_to_xml());
+RegisterExec(2926, arrow_table_to_xmlschema());
+RegisterExec(2927, arrow_query_to_xmlschema());
+RegisterExec(2928, arrow_cursor_to_xmlschema());
+RegisterExec(2929, arrow_table_to_xml_and_xmlschema());
+RegisterExec(2930, arrow_query_to_xml_and_xmlschema());
+RegisterExec(2931, arrow_xpath());
+RegisterExec(2933, arrow_schema_to_xml());
+RegisterExec(2934, arrow_schema_to_xmlschema());
+RegisterExec(2935, arrow_schema_to_xml_and_xmlschema());
+RegisterExec(2936, arrow_database_to_xml());
+RegisterExec(2937, arrow_database_to_xmlschema());
+RegisterExec(2938, arrow_database_to_xml_and_xmlschema());
+RegisterExec(3000, arrow_has_foreign_data_wrapper_privilege_name_name());
+RegisterExec(3001, arrow_has_foreign_data_wrapper_privilege_name_id());
+RegisterExec(3002, arrow_has_foreign_data_wrapper_privilege_id_name());
+RegisterExec(3003, arrow_has_foreign_data_wrapper_privilege_id_id());
+RegisterExec(3004, arrow_has_foreign_data_wrapper_privilege_name());
+RegisterExec(3005, arrow_has_foreign_data_wrapper_privilege_id());
+RegisterExec(3006, arrow_has_server_privilege_name_name());
+RegisterExec(3007, arrow_has_server_privilege_name_id());
+RegisterExec(3008, arrow_has_server_privilege_id_name());
+RegisterExec(3009, arrow_has_server_privilege_id_id());
+RegisterExec(3010, arrow_has_server_privilege_name());
+RegisterExec(3011, arrow_has_server_privilege_id());
+RegisterExec(3012, arrow_has_column_privilege_name_name_name());
+RegisterExec(3013, arrow_has_column_privilege_name_name_attnum());
+RegisterExec(3014, arrow_has_column_privilege_name_id_name());
+RegisterExec(3015, arrow_has_column_privilege_name_id_attnum());
+RegisterExec(3016, arrow_has_column_privilege_id_name_name());
+RegisterExec(3017, arrow_has_column_privilege_id_name_attnum());
+RegisterExec(3018, arrow_has_column_privilege_id_id_name());
+RegisterExec(3019, arrow_has_column_privilege_id_id_attnum());
+RegisterExec(3020, arrow_has_column_privilege_name_name());
+RegisterExec(3021, arrow_has_column_privilege_name_attnum());
+RegisterExec(3022, arrow_has_column_privilege_id_name());
+RegisterExec(3023, arrow_has_column_privilege_id_attnum());
+RegisterExec(3024, arrow_has_any_column_privilege_name_name());
+RegisterExec(3025, arrow_has_any_column_privilege_name_id());
+RegisterExec(3026, arrow_has_any_column_privilege_id_name());
+RegisterExec(3027, arrow_has_any_column_privilege_id_id());
+RegisterExec(3028, arrow_has_any_column_privilege_name());
+RegisterExec(3029, arrow_has_any_column_privilege_id());
+RegisterExec(3036, arrow_pg_notify());
+RegisterExec(3049, arrow_xpath_exists());
+RegisterExec(3051, arrow_xml_is_well_formed());
+RegisterExec(3052, arrow_xml_is_well_formed_document());
+RegisterExec(3053, arrow_xml_is_well_formed_content());
+RegisterExec(3060, arrow_text_left());
+RegisterExec(3061, arrow_text_right());
+RegisterExec(3062, arrow_text_reverse());
+RegisterExec(3077, arrow_gin_extract_tsvector_2args());
+RegisterExec(3087, arrow_gin_extract_tsquery_5args());
+RegisterExec(3088, arrow_gin_tsquery_consistent_6args());
+RegisterExec(3089, arrow_pg_advisory_xact_lock_int8());
+RegisterExec(3090, arrow_pg_advisory_xact_lock_shared_int8());
+RegisterExec(3091, arrow_pg_try_advisory_xact_lock_int8());
+RegisterExec(3092, arrow_pg_try_advisory_xact_lock_shared_int8());
+RegisterExec(3093, arrow_pg_advisory_xact_lock_int4());
+RegisterExec(3094, arrow_pg_advisory_xact_lock_shared_int4());
+RegisterExec(3095, arrow_pg_try_advisory_xact_lock_int4());
+RegisterExec(3096, arrow_pg_try_advisory_xact_lock_shared_int4());
 RegisterExec(3136, arrow_date_sortsupport());
-RegisterExec(3150, arrow_pg_stat_get_db_temp_files());
-RegisterExec(3151, arrow_pg_stat_get_db_temp_bytes());
-RegisterExec(3152, arrow_pg_stat_get_db_deadlocks());
-RegisterExec(3159, arrow_pg_get_viewdef_wrap());
-RegisterExec(3160, arrow_pg_stat_get_checkpoint_write_time());
-RegisterExec(3161, arrow_pg_stat_get_checkpoint_sync_time());
-RegisterExec(3162, arrow_pg_collation_for());
-RegisterExec(3166, arrow_pg_size_pretty_numeric());
-RegisterExec(3177, arrow_pg_stat_get_mod_since_analyze());
-RegisterExec(3181, arrow_record_image_eq());
-RegisterExec(3182, arrow_record_image_ne());
-RegisterExec(3183, arrow_record_image_lt());
-RegisterExec(3184, arrow_record_image_gt());
-RegisterExec(3185, arrow_record_image_le());
-RegisterExec(3186, arrow_record_image_ge());
-RegisterExec(3187, arrow_btrecordimagecmp());
-RegisterExec(3195, arrow_pg_stat_get_archiver());
-RegisterExec(3293, arrow_pg_read_file_v2());
-RegisterExec(3295, arrow_pg_read_binary_file());
-RegisterExec(3307, arrow_pg_stat_file());
-RegisterExec(3308, arrow_xidneq());
-RegisterExec(3309, arrow_xidneq());
-RegisterExec(3334, arrow_pg_size_bytes());
-RegisterExec(3352, arrow_pg_get_partkeydef());
-RegisterExec(3355, arrow_pg_ndistinct_in());
-RegisterExec(3356, arrow_pg_ndistinct_out());
-RegisterExec(3357, arrow_pg_ndistinct_recv());
-RegisterExec(3358, arrow_pg_ndistinct_send());
-RegisterExec(3383, arrow_brin_minmax_opcinfo());
-RegisterExec(3384, arrow_brin_minmax_add_value());
-RegisterExec(3385, arrow_brin_minmax_consistent());
-RegisterExec(3386, arrow_brin_minmax_union());
-RegisterExec(3408, arrow_pg_get_partition_constraintdef());
+RegisterExec(3138, arrow_has_type_privilege_name_name());
+RegisterExec(3139, arrow_has_type_privilege_name_id());
+RegisterExec(3140, arrow_has_type_privilege_id_name());
+RegisterExec(3141, arrow_has_type_privilege_id_id());
+RegisterExec(3142, arrow_has_type_privilege_name());
+RegisterExec(3143, arrow_has_type_privilege_id());
+RegisterExec(3167, arrow_array_remove());
+RegisterExec(3168, arrow_array_replace());
+RegisterExec(3179, arrow_array_cardinality());
+RegisterExec(3218, arrow_width_bucket_array());
+RegisterExec(3255, arrow_bttextsortsupport());
+RegisterExec(3296, arrow_pg_notification_queue_usage());
+RegisterExec(3317, arrow_pg_stat_get_wal_receiver());
+RegisterExec(3319, arrow_tsvector_filter());
+RegisterExec(3320, arrow_tsvector_setweight_by_filter());
+RegisterExec(3321, arrow_tsvector_delete_str());
+RegisterExec(3323, arrow_tsvector_delete_arr());
+RegisterExec(3326, arrow_tsvector_to_array());
+RegisterExec(3327, arrow_array_to_tsvector());
+RegisterExec(3331, arrow_bytea_sortsupport());
+RegisterExec(3332, arrow_bttext_pattern_sortsupport());
+RegisterExec(3376, arrow_pg_safe_snapshot_blocking_pids());
+RegisterExec(3378, arrow_pg_isolation_test_session_is_blocked());
+RegisterExec(3404, arrow_pg_dependencies_in());
+RegisterExec(3405, arrow_pg_dependencies_out());
+RegisterExec(3406, arrow_pg_dependencies_recv());
+RegisterExec(3407, arrow_pg_dependencies_send());
 RegisterExec(3409, arrow_time_hash_extended());
 RegisterExec(3410, arrow_timetz_hash_extended());
-RegisterExec(3415, arrow_pg_get_statisticsobjdef());
-RegisterExec(3417, arrow_hash_range_extended());
-RegisterExec(3426, arrow_pg_stat_get_db_checksum_failures());
-RegisterExec(3428, arrow_pg_stat_get_db_checksum_last_failure());
+RegisterExec(3416, arrow_jsonb_hash_extended());
 RegisterExec(3445, arrow_pg_import_system_collations());
-RegisterExec(3446, arrow_macaddr8_recv());
-RegisterExec(3447, arrow_macaddr8_send());
 RegisterExec(3448, arrow_pg_collation_actual_version());
-RegisterExec(3454, arrow_pg_filenode_relation());
+RegisterExec(3469, arrow_spg_range_quad_config());
+RegisterExec(3470, arrow_spg_range_quad_choose());
+RegisterExec(3471, arrow_spg_range_quad_picksplit());
+RegisterExec(3472, arrow_spg_range_quad_inner_consistent());
+RegisterExec(3473, arrow_spg_range_quad_leaf_consistent());
 RegisterExec(3480, arrow_gin_compare_jsonb());
 RegisterExec(3482, arrow_gin_extract_jsonb());
 RegisterExec(3483, arrow_gin_extract_jsonb_query());
@@ -430,121 +585,126 @@ RegisterExec(3486, arrow_gin_extract_jsonb_query_path());
 RegisterExec(3487, arrow_gin_consistent_jsonb_path());
 RegisterExec(3488, arrow_gin_triconsistent_jsonb());
 RegisterExec(3489, arrow_gin_triconsistent_jsonb_path());
+RegisterExec(3535, arrow_string_agg_transfn());
+RegisterExec(3536, arrow_string_agg_finalfn());
+RegisterExec(3540, arrow_text_format_nv());
+RegisterExec(3543, arrow_bytea_string_agg_transfn());
+RegisterExec(3544, arrow_bytea_string_agg_finalfn());
 RegisterExec(3546, arrow_int8dec());
 RegisterExec(3547, arrow_int8dec_any());
-RegisterExec(3684, arrow_tsquery_rewrite());
-RegisterExec(3685, arrow_tsquery_rewrite_query());
+RegisterExec(3577, arrow_pg_logical_emit_message_text());
+RegisterExec(3578, arrow_pg_logical_emit_message_bytea());
+RegisterExec(3582, arrow_binary_upgrade_set_next_pg_type_oid());
+RegisterExec(3584, arrow_binary_upgrade_set_next_array_pg_type_oid());
+RegisterExec(3586, arrow_binary_upgrade_set_next_heap_pg_class_oid());
+RegisterExec(3587, arrow_binary_upgrade_set_next_index_pg_class_oid());
+RegisterExec(3588, arrow_binary_upgrade_set_next_toast_pg_class_oid());
+RegisterExec(3589, arrow_binary_upgrade_set_next_pg_enum_oid());
+RegisterExec(3590, arrow_binary_upgrade_set_next_pg_authid_oid());
+RegisterExec(3591, arrow_binary_upgrade_create_empty_extension());
+RegisterExec(3616, arrow_tsvector_lt());
+RegisterExec(3617, arrow_tsvector_le());
+RegisterExec(3618, arrow_tsvector_eq());
+RegisterExec(3619, arrow_tsvector_ne());
+RegisterExec(3620, arrow_tsvector_ge());
+RegisterExec(3621, arrow_tsvector_gt());
+RegisterExec(3622, arrow_tsvector_cmp());
+RegisterExec(3623, arrow_tsvector_strip());
+RegisterExec(3624, arrow_tsvector_setweight());
+RegisterExec(3625, arrow_tsvector_concat());
+RegisterExec(3634, arrow_ts_match_vq());
+RegisterExec(3635, arrow_ts_match_qv());
+RegisterExec(3656, arrow_gin_extract_tsvector());
+RegisterExec(3657, arrow_gin_extract_tsquery());
+RegisterExec(3658, arrow_gin_tsquery_consistent());
 RegisterExec(3695, arrow_gtsquery_compress());
+RegisterExec(3696, arrow_text_starts_with());
 RegisterExec(3697, arrow_gtsquery_picksplit());
 RegisterExec(3698, arrow_gtsquery_union());
 RegisterExec(3699, arrow_gtsquery_same());
 RegisterExec(3700, arrow_gtsquery_penalty());
 RegisterExec(3701, arrow_gtsquery_consistent());
+RegisterExec(3703, arrow_ts_rank_wttf());
+RegisterExec(3704, arrow_ts_rank_wtt());
+RegisterExec(3705, arrow_ts_rank_ttf());
+RegisterExec(3706, arrow_ts_rank_tt());
+RegisterExec(3707, arrow_ts_rankcd_wttf());
+RegisterExec(3708, arrow_ts_rankcd_wtt());
+RegisterExec(3709, arrow_ts_rankcd_ttf());
+RegisterExec(3710, arrow_ts_rankcd_tt());
+RegisterExec(3711, arrow_tsvector_length());
+RegisterExec(3724, arrow_gin_cmp_tslexeme());
+RegisterExec(3725, arrow_dsimple_init());
+RegisterExec(3726, arrow_dsimple_lexize());
 RegisterExec(3743, arrow_ts_headline_byid_opt());
 RegisterExec(3744, arrow_ts_headline_byid());
+RegisterExec(3745, arrow_to_tsvector_byid());
+RegisterExec(3746, arrow_to_tsquery_byid());
+RegisterExec(3747, arrow_plainto_tsquery_byid());
+RegisterExec(3749, arrow_to_tsvector());
+RegisterExec(3750, arrow_to_tsquery());
+RegisterExec(3751, arrow_plainto_tsquery());
+RegisterExec(3752, arrow_tsvector_update_trigger_byid());
+RegisterExec(3753, arrow_tsvector_update_trigger_bycolumn());
 RegisterExec(3754, arrow_ts_headline_opt());
 RegisterExec(3755, arrow_ts_headline());
-RegisterExec(3775, arrow_pg_stat_reset_shared());
-RegisterExec(3776, arrow_pg_stat_reset_single_table_counters());
-RegisterExec(3777, arrow_pg_stat_reset_single_function_counters());
-RegisterExec(3778, arrow_pg_tablespace_location());
-RegisterExec(3788, arrow_pg_stat_get_snapshot_timestamp());
-RegisterExec(3789, arrow_gin_clean_pending_list());
+RegisterExec(3759, arrow_get_current_ts_config());
+RegisterExec(3760, arrow_ts_match_tt());
+RegisterExec(3761, arrow_ts_match_tq());
+RegisterExec(3791, arrow_gin_extract_tsquery_oldsig());
+RegisterExec(3792, arrow_gin_tsquery_consistent_oldsig());
 RegisterExec(3793, arrow_gtsquery_consistent_oldsig());
-RegisterExec(3800, arrow_pg_current_logfile());
-RegisterExec(3801, arrow_pg_current_logfile_1arg());
-RegisterExec(3808, arrow_pg_get_function_arg_default());
-RegisterExec(3816, arrow_array_typanalyze());
-RegisterExec(3817, arrow_arraycontsel());
-RegisterExec(3818, arrow_arraycontjoinsel());
-RegisterExec(3826, arrow_pg_read_file_all());
-RegisterExec(3827, arrow_pg_read_binary_file_off_len());
-RegisterExec(3828, arrow_pg_read_binary_file_all());
-RegisterExec(3834, arrow_range_in());
-RegisterExec(3835, arrow_range_out());
-RegisterExec(3836, arrow_range_recv());
-RegisterExec(3837, arrow_range_send());
-RegisterExec(3840, arrow_range_constructor2());
-RegisterExec(3844, arrow_range_constructor2());
-RegisterExec(3933, arrow_range_constructor2());
-RegisterExec(3937, arrow_range_constructor2());
-RegisterExec(3941, arrow_range_constructor2());
-RegisterExec(3945, arrow_range_constructor2());
-RegisterExec(3841, arrow_range_constructor3());
-RegisterExec(3845, arrow_range_constructor3());
-RegisterExec(3934, arrow_range_constructor3());
-RegisterExec(3938, arrow_range_constructor3());
-RegisterExec(3942, arrow_range_constructor3());
-RegisterExec(3946, arrow_range_constructor3());
-RegisterExec(3842, arrow_pg_relation_is_updatable());
-RegisterExec(3843, arrow_pg_column_is_updatable());
+RegisterExec(3795, arrow_inet_spg_config());
+RegisterExec(3796, arrow_inet_spg_choose());
+RegisterExec(3797, arrow_inet_spg_picksplit());
+RegisterExec(3798, arrow_inet_spg_inner_consistent());
+RegisterExec(3799, arrow_inet_spg_leaf_consistent());
 RegisterExec(3846, arrow_make_date());
 RegisterExec(3847, arrow_make_time());
-RegisterExec(3848, arrow_range_lower());
-RegisterExec(3849, arrow_range_upper());
-RegisterExec(3850, arrow_range_empty());
-RegisterExec(3851, arrow_range_lower_inc());
-RegisterExec(3852, arrow_range_upper_inc());
-RegisterExec(3853, arrow_range_lower_inf());
-RegisterExec(3854, arrow_range_upper_inf());
-RegisterExec(3855, arrow_range_eq());
-RegisterExec(3856, arrow_range_ne());
-RegisterExec(3857, arrow_range_overlaps());
-RegisterExec(3858, arrow_range_contains_elem());
-RegisterExec(3859, arrow_range_contains());
-RegisterExec(3860, arrow_elem_contained_by_range());
-RegisterExec(3861, arrow_range_contained_by());
-RegisterExec(3862, arrow_range_adjacent());
-RegisterExec(3863, arrow_range_before());
-RegisterExec(3864, arrow_range_after());
-RegisterExec(3865, arrow_range_overleft());
-RegisterExec(3866, arrow_range_overright());
-RegisterExec(3867, arrow_range_union());
-RegisterExec(3868, arrow_range_intersect());
-RegisterExec(3869, arrow_range_minus());
-RegisterExec(3870, arrow_range_cmp());
-RegisterExec(3871, arrow_range_lt());
-RegisterExec(3872, arrow_range_le());
-RegisterExec(3873, arrow_range_ge());
-RegisterExec(3874, arrow_range_gt());
 RegisterExec(3875, arrow_range_gist_consistent());
 RegisterExec(3876, arrow_range_gist_union());
 RegisterExec(3879, arrow_range_gist_penalty());
 RegisterExec(3880, arrow_range_gist_picksplit());
 RegisterExec(3881, arrow_range_gist_same());
-RegisterExec(3902, arrow_hash_range());
-RegisterExec(3914, arrow_int4range_canonical());
-RegisterExec(3915, arrow_daterange_canonical());
-RegisterExec(3922, arrow_int4range_subdiff());
-RegisterExec(3923, arrow_int8range_subdiff());
-RegisterExec(3924, arrow_numrange_subdiff());
-RegisterExec(3925, arrow_daterange_subdiff());
-RegisterExec(3928, arrow_int8range_canonical());
-RegisterExec(3929, arrow_tsrange_subdiff());
-RegisterExec(3930, arrow_tstzrange_subdiff());
-RegisterExec(3939, arrow_mxid_age());
+RegisterExec(3916, arrow_range_typanalyze());
+RegisterExec(3921, arrow_gin_tsquery_triconsistent());
+RegisterExec(3943, arrow_acldefault_sql());
 RegisterExec(3944, arrow_time_support());
+RegisterExec(3994, arrow_generate_series_int4_support());
 RegisterExec(3995, arrow_generate_series_int8_support());
-RegisterExec(4032, arrow_pg_sequence_last_value());
-RegisterExec(4057, arrow_range_merge());
-RegisterExec(4100, arrow_pg_read_file());
-RegisterExec(4110, arrow_macaddr8_in());
-RegisterExec(4111, arrow_macaddr8_out());
-RegisterExec(4112, arrow_macaddr8_trunc());
-RegisterExec(4113, arrow_macaddr8_eq());
-RegisterExec(4114, arrow_macaddr8_lt());
-RegisterExec(4115, arrow_macaddr8_le());
-RegisterExec(4116, arrow_macaddr8_gt());
-RegisterExec(4117, arrow_macaddr8_ge());
-RegisterExec(4118, arrow_macaddr8_ne());
-RegisterExec(4119, arrow_macaddr8_cmp());
-RegisterExec(4120, arrow_macaddr8_not());
-RegisterExec(4121, arrow_macaddr8_and());
-RegisterExec(4122, arrow_macaddr8_or());
-RegisterExec(4123, arrow_macaddrtomacaddr8());
-RegisterExec(4124, arrow_macaddr8tomacaddr());
-RegisterExec(4125, arrow_macaddr8_set7bit());
+RegisterExec(3996, arrow_array_unnest_support());
+RegisterExec(4005, arrow_jsonb_path_exists());
+RegisterExec(4007, arrow_jsonb_path_query_array());
+RegisterExec(4008, arrow_jsonb_path_query_first());
+RegisterExec(4009, arrow_jsonb_path_match());
+RegisterExec(4010, arrow_jsonb_path_exists_opr());
+RegisterExec(4011, arrow_jsonb_path_match_opr());
+RegisterExec(4038, arrow_jsonb_ne());
+RegisterExec(4039, arrow_jsonb_lt());
+RegisterExec(4040, arrow_jsonb_gt());
+RegisterExec(4041, arrow_jsonb_le());
+RegisterExec(4042, arrow_jsonb_ge());
+RegisterExec(4043, arrow_jsonb_eq());
+RegisterExec(4044, arrow_jsonb_cmp());
+RegisterExec(4045, arrow_jsonb_hash());
+RegisterExec(4046, arrow_jsonb_contains());
+RegisterExec(4047, arrow_jsonb_exists());
+RegisterExec(4048, arrow_jsonb_exists_any());
+RegisterExec(4049, arrow_jsonb_exists_all());
+RegisterExec(4050, arrow_jsonb_contained());
+RegisterExec(4083, arrow_binary_upgrade_set_record_init_privs());
+RegisterExec(4101, arrow_binary_upgrade_set_missing_value());
+RegisterExec(4105, arrow_brin_inclusion_opcinfo());
+RegisterExec(4106, arrow_brin_inclusion_add_value());
+RegisterExec(4107, arrow_brin_inclusion_consistent());
+RegisterExec(4108, arrow_brin_inclusion_union());
 RegisterExec(4126, arrow_in_range_int8_int8());
+RegisterExec(4127, arrow_in_range_int4_int8());
+RegisterExec(4128, arrow_in_range_int4_int4());
+RegisterExec(4129, arrow_in_range_int4_int2());
+RegisterExec(4130, arrow_in_range_int2_int8());
+RegisterExec(4131, arrow_in_range_int2_int4());
+RegisterExec(4132, arrow_in_range_int2_int2());
 RegisterExec(4133, arrow_in_range_date_interval());
 RegisterExec(4137, arrow_in_range_time_interval());
 RegisterExec(4138, arrow_in_range_timetz_interval());
@@ -556,54 +716,41 @@ RegisterExec(4205, arrow_ts_headline_json_byid_opt());
 RegisterExec(4206, arrow_ts_headline_json_byid());
 RegisterExec(4207, arrow_ts_headline_json_opt());
 RegisterExec(4208, arrow_ts_headline_json());
-RegisterExec(4401, arrow_range_intersect_agg_transfn());
-RegisterExec(4543, arrow_pg_log_backend_memory_contexts());
+RegisterExec(4209, arrow_jsonb_string_to_tsvector());
+RegisterExec(4210, arrow_json_string_to_tsvector());
+RegisterExec(4211, arrow_jsonb_string_to_tsvector_byid());
+RegisterExec(4212, arrow_json_string_to_tsvector_byid());
+RegisterExec(4213, arrow_jsonb_to_tsvector());
+RegisterExec(4214, arrow_jsonb_to_tsvector_byid());
+RegisterExec(4215, arrow_json_to_tsvector());
+RegisterExec(4216, arrow_json_to_tsvector_byid());
+RegisterExec(4242, arrow_multirange_typanalyze());
+RegisterExec(4350, arrow_unicode_normalize_func());
+RegisterExec(4351, arrow_unicode_is_normalized());
+RegisterExec(4390, arrow_binary_upgrade_set_next_multirange_pg_type_oid());
+RegisterExec(4391, arrow_binary_upgrade_set_next_multirange_array_pg_type_oid());
+RegisterExec(4566, arrow_pg_event_trigger_table_rewrite_oid());
+RegisterExec(4567, arrow_pg_event_trigger_table_rewrite_reason());
+RegisterExec(5001, arrow_phraseto_tsquery());
+RegisterExec(5006, arrow_phraseto_tsquery_byid());
+RegisterExec(5007, arrow_websearch_to_tsquery_byid());
+RegisterExec(5009, arrow_websearch_to_tsquery());
 RegisterExec(5018, arrow_pg_mcv_list_in());
 RegisterExec(5019, arrow_pg_mcv_list_out());
 RegisterExec(5020, arrow_pg_mcv_list_recv());
 RegisterExec(5021, arrow_pg_mcv_list_send());
-RegisterExec(5034, arrow_xid8lt());
-RegisterExec(5035, arrow_xid8gt());
-RegisterExec(5036, arrow_xid8le());
-RegisterExec(5037, arrow_xid8ge());
+RegisterExec(5044, arrow_int4gcd());
 RegisterExec(5045, arrow_int8gcd());
+RegisterExec(5046, arrow_int4lcm());
 RegisterExec(5047, arrow_int8lcm());
-RegisterExec(5053, arrow_pg_stat_get_ins_since_vacuum());
-RegisterExec(5070, arrow_xid8in());
-RegisterExec(5071, arrow_xid8toxid());
-RegisterExec(5081, arrow_xid8out());
-RegisterExec(5082, arrow_xid8recv());
-RegisterExec(5083, arrow_xid8send());
-RegisterExec(5084, arrow_xid8eq());
-RegisterExec(5085, arrow_xid8ne());
-RegisterExec(5096, arrow_xid8cmp());
-RegisterExec(6003, arrow_pg_replication_origin_create());
-RegisterExec(6004, arrow_pg_replication_origin_drop());
-RegisterExec(6005, arrow_pg_replication_origin_oid());
-RegisterExec(6006, arrow_pg_replication_origin_session_setup());
-RegisterExec(6007, arrow_pg_replication_origin_session_reset());
-RegisterExec(6008, arrow_pg_replication_origin_session_is_setup());
-RegisterExec(6009, arrow_pg_replication_origin_session_progress());
-RegisterExec(6010, arrow_pg_replication_origin_xact_setup());
-RegisterExec(6011, arrow_pg_replication_origin_xact_reset());
-RegisterExec(6012, arrow_pg_replication_origin_advance());
-RegisterExec(6013, arrow_pg_replication_origin_progress());
-RegisterExec(6120, arrow_pg_get_replica_identity_index());
+RegisterExec(5050, arrow_btvarstrequalimage());
+RegisterExec(5051, arrow_btequalimage());
+RegisterExec(6121, arrow_pg_relation_is_publishable());
 RegisterExec(6154, arrow_multirange_gist_consistent());
 RegisterExec(6156, arrow_multirange_gist_compress());
-RegisterExec(6170, arrow_pg_stat_reset_replication_slot());
-RegisterExec(6173, arrow_pg_get_statisticsobjdef_expressions());
-RegisterExec(6174, arrow_pg_get_statisticsobjdef_columns());
-RegisterExec(6185, arrow_pg_stat_get_db_session_time());
-RegisterExec(6186, arrow_pg_stat_get_db_active_time());
-RegisterExec(6187, arrow_pg_stat_get_db_idle_in_transaction_time());
-RegisterExec(6188, arrow_pg_stat_get_db_sessions());
-RegisterExec(6189, arrow_pg_stat_get_db_sessions_abandoned());
-RegisterExec(6190, arrow_pg_stat_get_db_sessions_fatal());
-RegisterExec(6191, arrow_pg_stat_get_db_sessions_killed());
-RegisterExec(6192, arrow_hash_record());
-RegisterExec(6193, arrow_hash_record_extended());
-RegisterExec(6197, arrow_pg_get_function_sqlbody());
+RegisterExec(6163, arrow_bytea_bit_count());
+RegisterExec(6172, arrow_trim_array());
+RegisterExec(6198, arrow_unistr());
 RegisterExec(6199, arrow_extract_date());
 RegisterExec(6200, arrow_extract_time());
 RegisterExec(6201, arrow_extract_timetz());
diff --git a/ydb/library/yql/parser/pg_wrapper/pg_kernels_register.2.inc b/ydb/library/yql/parser/pg_wrapper/pg_kernels_register.2.inc
index 7513e0bdb6c..39edd1a5104 100644
--- a/ydb/library/yql/parser/pg_wrapper/pg_kernels_register.2.inc
+++ b/ydb/library/yql/parser/pg_wrapper/pg_kernels_register.2.inc
@@ -1,252 +1,147 @@
-RegisterExec(3, arrow_heap_tableam_handler());
-RegisterExec(89, arrow_pgsql_version());
-RegisterExec(101, arrow_eqsel());
-RegisterExec(102, arrow_neqsel());
-RegisterExec(103, arrow_scalarltsel());
-RegisterExec(104, arrow_scalargtsel());
-RegisterExec(105, arrow_eqjoinsel());
-RegisterExec(106, arrow_neqjoinsel());
-RegisterExec(107, arrow_scalarltjoinsel());
-RegisterExec(108, arrow_scalargtjoinsel());
-RegisterExec(115, arrow_box_above_eq());
-RegisterExec(116, arrow_box_below_eq());
-RegisterExec(117, arrow_point_in());
-RegisterExec(118, arrow_point_out());
-RegisterExec(119, arrow_lseg_in());
-RegisterExec(120, arrow_lseg_out());
-RegisterExec(121, arrow_path_in());
-RegisterExec(122, arrow_path_out());
-RegisterExec(123, arrow_box_in());
-RegisterExec(124, arrow_box_out());
-RegisterExec(125, arrow_box_overlap());
-RegisterExec(126, arrow_box_ge());
-RegisterExec(127, arrow_box_gt());
-RegisterExec(128, arrow_box_eq());
-RegisterExec(129, arrow_box_lt());
-RegisterExec(130, arrow_box_le());
-RegisterExec(131, arrow_point_above());
-RegisterExec(132, arrow_point_left());
-RegisterExec(133, arrow_point_right());
-RegisterExec(134, arrow_point_below());
-RegisterExec(135, arrow_point_eq());
-RegisterExec(136, arrow_on_pb());
-RegisterExec(137, arrow_on_ppath());
-RegisterExec(138, arrow_box_center());
-RegisterExec(1534, arrow_box_center());
-RegisterExec(1542, arrow_box_center());
-RegisterExec(186, arrow_box_same());
-RegisterExec(187, arrow_box_contain());
-RegisterExec(188, arrow_box_left());
-RegisterExec(189, arrow_box_overleft());
-RegisterExec(190, arrow_box_overright());
-RegisterExec(191, arrow_box_right());
-RegisterExec(192, arrow_box_contained());
-RegisterExec(193, arrow_box_contain_pt());
-RegisterExec(225, arrow_lseg_center());
-RegisterExec(1532, arrow_lseg_center());
-RegisterExec(226, arrow_path_center());
-RegisterExec(1533, arrow_path_center());
-RegisterExec(227, arrow_poly_center());
-RegisterExec(1540, arrow_poly_center());
-RegisterExec(239, arrow_line_distance());
-RegisterExec(275, arrow_pg_nextoid());
-RegisterExec(277, arrow_inter_sl());
-RegisterExec(278, arrow_inter_lb());
-RegisterExec(321, arrow_json_in());
-RegisterExec(322, arrow_json_out());
-RegisterExec(323, arrow_json_recv());
-RegisterExec(324, arrow_json_send());
-RegisterExec(329, arrow_hash_aclitem());
-RegisterExec(335, arrow_brinhandler());
-RegisterExec(336, arrow_scalarlesel());
-RegisterExec(337, arrow_scalargesel());
-RegisterExec(339, arrow_poly_same());
-RegisterExec(340, arrow_poly_contain());
-RegisterExec(341, arrow_poly_left());
-RegisterExec(342, arrow_poly_overleft());
-RegisterExec(343, arrow_poly_overright());
-RegisterExec(344, arrow_poly_right());
-RegisterExec(345, arrow_poly_contained());
-RegisterExec(346, arrow_poly_overlap());
-RegisterExec(347, arrow_poly_in());
-RegisterExec(348, arrow_poly_out());
-RegisterExec(350, arrow_btint2cmp());
-RegisterExec(351, arrow_btint4cmp());
-RegisterExec(356, arrow_btoidcmp());
-RegisterExec(357, arrow_dist_bp());
-RegisterExec(358, arrow_btcharcmp());
-RegisterExec(361, arrow_lseg_distance());
-RegisterExec(362, arrow_lseg_interpt());
-RegisterExec(363, arrow_dist_ps());
-RegisterExec(364, arrow_dist_pb());
-RegisterExec(365, arrow_dist_sb());
-RegisterExec(366, arrow_close_ps());
-RegisterExec(367, arrow_close_pb());
-RegisterExec(368, arrow_close_sb());
-RegisterExec(369, arrow_on_ps());
-RegisterExec(370, arrow_path_distance());
-RegisterExec(371, arrow_dist_ppath());
-RegisterExec(372, arrow_on_sb());
-RegisterExec(373, arrow_inter_sb());
-RegisterExec(378, arrow_array_append());
-RegisterExec(379, arrow_array_prepend());
-RegisterExec(380, arrow_dist_sp());
-RegisterExec(381, arrow_dist_bs());
-RegisterExec(382, arrow_btarraycmp());
-RegisterExec(383, arrow_array_cat());
-RegisterExec(386, arrow_scalarlejoinsel());
-RegisterExec(390, arrow_array_ne());
-RegisterExec(391, arrow_array_lt());
-RegisterExec(392, arrow_array_gt());
-RegisterExec(393, arrow_array_le());
-RegisterExec(396, arrow_array_ge());
-RegisterExec(398, arrow_scalargejoinsel());
-RegisterExec(400, arrow_hashtext());
-RegisterExec(401, arrow_rtrim1());
-RegisterExec(882, arrow_rtrim1());
-RegisterExec(404, arrow_btoidvectorcmp());
+RegisterExec(34, arrow_namein());
+RegisterExec(35, arrow_nameout());
+RegisterExec(50, arrow_xidin());
+RegisterExec(51, arrow_xidout());
+RegisterExec(52, arrow_cidin());
+RegisterExec(53, arrow_cidout());
+RegisterExec(62, arrow_nameeq());
+RegisterExec(68, arrow_xideq());
+RegisterExec(1319, arrow_xideq());
+RegisterExec(69, arrow_cideq());
+RegisterExec(86, arrow_pg_ddl_command_in());
+RegisterExec(87, arrow_pg_ddl_command_out());
+RegisterExec(88, arrow_pg_ddl_command_recv());
+RegisterExec(90, arrow_pg_ddl_command_send());
+RegisterExec(195, arrow_pg_node_tree_in());
+RegisterExec(196, arrow_pg_node_tree_out());
+RegisterExec(197, arrow_pg_node_tree_recv());
+RegisterExec(198, arrow_pg_node_tree_send());
+RegisterExec(200, arrow_float4in());
+RegisterExec(201, arrow_float4out());
+RegisterExec(202, arrow_float4mul());
+RegisterExec(203, arrow_float4div());
+RegisterExec(204, arrow_float4pl());
+RegisterExec(205, arrow_float4mi());
+RegisterExec(206, arrow_float4um());
+RegisterExec(207, arrow_float4abs());
+RegisterExec(1394, arrow_float4abs());
+RegisterExec(208, arrow_float4_accum());
+RegisterExec(209, arrow_float4larger());
+RegisterExec(211, arrow_float4smaller());
+RegisterExec(214, arrow_float8in());
+RegisterExec(215, arrow_float8out());
+RegisterExec(216, arrow_float8mul());
+RegisterExec(217, arrow_float8div());
+RegisterExec(218, arrow_float8pl());
+RegisterExec(219, arrow_float8mi());
+RegisterExec(220, arrow_float8um());
+RegisterExec(221, arrow_float8abs());
+RegisterExec(1395, arrow_float8abs());
+RegisterExec(222, arrow_float8_accum());
+RegisterExec(223, arrow_float8larger());
+RegisterExec(224, arrow_float8smaller());
+RegisterExec(228, arrow_dround());
+RegisterExec(1342, arrow_dround());
+RegisterExec(229, arrow_dtrunc());
+RegisterExec(1343, arrow_dtrunc());
+RegisterExec(230, arrow_dsqrt());
+RegisterExec(1344, arrow_dsqrt());
+RegisterExec(231, arrow_dcbrt());
+RegisterExec(1345, arrow_dcbrt());
+RegisterExec(232, arrow_dpow());
+RegisterExec(1346, arrow_dpow());
+RegisterExec(1368, arrow_dpow());
+RegisterExec(233, arrow_dexp());
+RegisterExec(1347, arrow_dexp());
+RegisterExec(234, arrow_dlog1());
+RegisterExec(1341, arrow_dlog1());
+RegisterExec(235, arrow_i2tod());
+RegisterExec(236, arrow_i2tof());
+RegisterExec(237, arrow_dtoi2());
+RegisterExec(238, arrow_ftoi2());
+RegisterExec(266, arrow_nameconcatoid());
+RegisterExec(267, arrow_table_am_handler_in());
+RegisterExec(268, arrow_table_am_handler_out());
+RegisterExec(276, arrow_float8_combine());
+RegisterExec(279, arrow_float48mul());
+RegisterExec(280, arrow_float48div());
+RegisterExec(281, arrow_float48pl());
+RegisterExec(282, arrow_float48mi());
+RegisterExec(283, arrow_float84mul());
+RegisterExec(284, arrow_float84div());
+RegisterExec(285, arrow_float84pl());
+RegisterExec(286, arrow_float84mi());
+RegisterExec(287, arrow_float4eq());
+RegisterExec(288, arrow_float4ne());
+RegisterExec(289, arrow_float4lt());
+RegisterExec(290, arrow_float4le());
+RegisterExec(291, arrow_float4gt());
+RegisterExec(292, arrow_float4ge());
+RegisterExec(293, arrow_float8eq());
+RegisterExec(294, arrow_float8ne());
+RegisterExec(295, arrow_float8lt());
+RegisterExec(296, arrow_float8le());
+RegisterExec(297, arrow_float8gt());
+RegisterExec(298, arrow_float8ge());
+RegisterExec(299, arrow_float48eq());
+RegisterExec(300, arrow_float48ne());
+RegisterExec(301, arrow_float48lt());
+RegisterExec(302, arrow_float48le());
+RegisterExec(303, arrow_float48gt());
+RegisterExec(304, arrow_float48ge());
+RegisterExec(305, arrow_float84eq());
+RegisterExec(306, arrow_float84ne());
+RegisterExec(307, arrow_float84lt());
+RegisterExec(308, arrow_float84le());
+RegisterExec(309, arrow_float84gt());
+RegisterExec(310, arrow_float84ge());
+RegisterExec(311, arrow_ftod());
+RegisterExec(312, arrow_dtof());
+RegisterExec(315, arrow_pg_jit_available());
+RegisterExec(316, arrow_i4tod());
+RegisterExec(317, arrow_dtoi4());
+RegisterExec(318, arrow_i4tof());
+RegisterExec(319, arrow_ftoi4());
+RegisterExec(320, arrow_width_bucket_float8());
+RegisterExec(326, arrow_index_am_handler_in());
+RegisterExec(327, arrow_index_am_handler_out());
+RegisterExec(331, arrow_hashhandler());
+RegisterExec(333, arrow_ginhandler());
+RegisterExec(334, arrow_spghandler());
+RegisterExec(354, arrow_btfloat4cmp());
+RegisterExec(355, arrow_btfloat8cmp());
+RegisterExec(359, arrow_btnamecmp());
+RegisterExec(399, arrow_hashmacaddr());
 RegisterExec(408, arrow_name_bpchar());
 RegisterExec(409, arrow_bpchar_name());
-RegisterExec(421, arrow_dist_pathp());
-RegisterExec(422, arrow_hashinet());
-RegisterExec(425, arrow_hashint4extended());
-RegisterExec(441, arrow_hashint2extended());
-RegisterExec(442, arrow_hashint8extended());
-RegisterExec(443, arrow_hashfloat4extended());
-RegisterExec(444, arrow_hashfloat8extended());
-RegisterExec(445, arrow_hashoidextended());
-RegisterExec(446, arrow_hashcharextended());
-RegisterExec(447, arrow_hashnameextended());
-RegisterExec(448, arrow_hashtextextended());
-RegisterExec(449, arrow_hashint2());
-RegisterExec(450, arrow_hashint4());
-RegisterExec(451, arrow_hashfloat4());
-RegisterExec(452, arrow_hashfloat8());
-RegisterExec(453, arrow_hashoid());
-RegisterExec(454, arrow_hashchar());
-RegisterExec(455, arrow_hashname());
-RegisterExec(456, arrow_hashvarlena());
-RegisterExec(457, arrow_hashoidvector());
-RegisterExec(515, arrow_array_larger());
-RegisterExec(516, arrow_array_smaller());
-RegisterExec(598, arrow_inet_abbrev());
-RegisterExec(599, arrow_cidr_abbrev());
-RegisterExec(605, arrow_inet_set_masklen());
-RegisterExec(626, arrow_hash_array());
-RegisterExec(635, arrow_cidr_set_masklen());
+RegisterExec(436, arrow_macaddr_in());
+RegisterExec(437, arrow_macaddr_out());
+RegisterExec(636, arrow_pg_indexam_has_property());
+RegisterExec(637, arrow_pg_index_has_property());
+RegisterExec(638, arrow_pg_index_column_has_property());
+RegisterExec(655, arrow_namelt());
+RegisterExec(656, arrow_namele());
+RegisterExec(657, arrow_namegt());
+RegisterExec(658, arrow_namege());
+RegisterExec(659, arrow_namene());
 RegisterExec(668, arrow_bpchar());
 RegisterExec(669, arrow_varchar());
-RegisterExec(683, arrow_network_network());
-RegisterExec(696, arrow_network_netmask());
-RegisterExec(697, arrow_network_masklen());
-RegisterExec(698, arrow_network_broadcast());
-RegisterExec(699, arrow_network_host());
-RegisterExec(702, arrow_dist_lp());
-RegisterExec(703, arrow_dist_bl());
-RegisterExec(704, arrow_dist_ls());
-RegisterExec(711, arrow_network_family());
-RegisterExec(725, arrow_dist_pl());
-RegisterExec(726, arrow_dist_lb());
-RegisterExec(727, arrow_dist_sl());
-RegisterExec(728, arrow_dist_cpoly());
-RegisterExec(729, arrow_poly_distance());
-RegisterExec(730, arrow_network_show());
-RegisterExec(744, arrow_array_eq());
-RegisterExec(747, arrow_array_dims());
-RegisterExec(748, arrow_array_ndims());
-RegisterExec(750, arrow_array_in());
-RegisterExec(751, arrow_array_out());
-RegisterExec(772, arrow_hashvarlenaextended());
-RegisterExec(776, arrow_hashoidvectorextended());
-RegisterExec(777, arrow_hash_aclitem_extended());
-RegisterExec(779, arrow_hashinetextended());
-RegisterExec(782, arrow_hash_array_extended());
-RegisterExec(785, arrow_dist_polyc());
-RegisterExec(810, arrow_pg_client_encoding());
-RegisterExec(842, arrow_btint8cmp());
-RegisterExec(850, arrow_textlike());
-RegisterExec(1569, arrow_textlike());
-RegisterExec(1631, arrow_textlike());
-RegisterExec(851, arrow_textnlike());
-RegisterExec(1570, arrow_textnlike());
-RegisterExec(1632, arrow_textnlike());
-RegisterExec(858, arrow_namelike());
-RegisterExec(1571, arrow_namelike());
-RegisterExec(859, arrow_namenlike());
-RegisterExec(1572, arrow_namenlike());
+RegisterExec(676, arrow_pg_indexam_progress_phasename());
+RegisterExec(710, arrow_current_user());
+RegisterExec(745, arrow_current_user());
+RegisterExec(746, arrow_session_user());
+RegisterExec(753, arrow_macaddr_trunc());
+RegisterExec(778, arrow_hashmacaddrextended());
+RegisterExec(830, arrow_macaddr_eq());
+RegisterExec(831, arrow_macaddr_lt());
+RegisterExec(832, arrow_macaddr_le());
+RegisterExec(833, arrow_macaddr_gt());
+RegisterExec(834, arrow_macaddr_ge());
+RegisterExec(835, arrow_macaddr_ne());
+RegisterExec(836, arrow_macaddr_cmp());
 RegisterExec(860, arrow_char_bpchar());
-RegisterExec(870, arrow_lower());
-RegisterExec(871, arrow_upper());
-RegisterExec(872, arrow_initcap());
-RegisterExec(873, arrow_lpad());
-RegisterExec(874, arrow_rpad());
-RegisterExec(875, arrow_ltrim());
-RegisterExec(876, arrow_rtrim());
-RegisterExec(878, arrow_translate());
-RegisterExec(881, arrow_ltrim1());
-RegisterExec(884, arrow_btrim());
-RegisterExec(885, arrow_btrim1());
-RegisterExec(910, arrow_inet_in());
-RegisterExec(911, arrow_inet_out());
-RegisterExec(920, arrow_network_eq());
-RegisterExec(921, arrow_network_lt());
-RegisterExec(922, arrow_network_le());
-RegisterExec(923, arrow_network_gt());
-RegisterExec(924, arrow_network_ge());
-RegisterExec(925, arrow_network_ne());
-RegisterExec(926, arrow_network_cmp());
-RegisterExec(927, arrow_network_sub());
-RegisterExec(928, arrow_network_subeq());
-RegisterExec(929, arrow_network_sup());
-RegisterExec(930, arrow_network_supeq());
-RegisterExec(949, arrow_hashint8());
-RegisterExec(959, arrow_on_pl());
-RegisterExec(960, arrow_on_sl());
-RegisterExec(961, arrow_close_pl());
-RegisterExec(962, arrow_close_sl());
-RegisterExec(963, arrow_close_lb());
 RegisterExec(972, arrow_hashbpcharextended());
-RegisterExec(973, arrow_path_inter());
-RegisterExec(975, arrow_box_area());
-RegisterExec(976, arrow_box_width());
-RegisterExec(977, arrow_box_height());
-RegisterExec(978, arrow_box_distance());
-RegisterExec(979, arrow_path_area());
-RegisterExec(980, arrow_box_intersect());
-RegisterExec(981, arrow_box_diagonal());
-RegisterExec(1541, arrow_box_diagonal());
-RegisterExec(982, arrow_path_n_lt());
-RegisterExec(983, arrow_path_n_gt());
-RegisterExec(984, arrow_path_n_eq());
-RegisterExec(985, arrow_path_n_le());
-RegisterExec(986, arrow_path_n_ge());
-RegisterExec(987, arrow_path_length());
-RegisterExec(1531, arrow_path_length());
-RegisterExec(988, arrow_point_ne());
-RegisterExec(989, arrow_point_vert());
-RegisterExec(1406, arrow_point_vert());
-RegisterExec(990, arrow_point_horiz());
-RegisterExec(1407, arrow_point_horiz());
-RegisterExec(991, arrow_point_distance());
-RegisterExec(992, arrow_point_slope());
-RegisterExec(993, arrow_lseg_construct());
-RegisterExec(994, arrow_lseg_intersect());
-RegisterExec(995, arrow_lseg_parallel());
-RegisterExec(1408, arrow_lseg_parallel());
-RegisterExec(996, arrow_lseg_perp());
-RegisterExec(1409, arrow_lseg_perp());
-RegisterExec(997, arrow_lseg_vertical());
-RegisterExec(1410, arrow_lseg_vertical());
-RegisterExec(998, arrow_lseg_horizontal());
-RegisterExec(1411, arrow_lseg_horizontal());
-RegisterExec(999, arrow_lseg_eq());
 RegisterExec(1030, arrow_gist_point_compress());
-RegisterExec(1031, arrow_aclitemin());
-RegisterExec(1032, arrow_aclitemout());
-RegisterExec(1035, arrow_aclinsert());
-RegisterExec(1036, arrow_aclremove());
-RegisterExec(1037, arrow_aclcontains());
-RegisterExec(1039, arrow_getdatabaseencoding());
 RegisterExec(1044, arrow_bpcharin());
 RegisterExec(1045, arrow_bpcharout());
 RegisterExec(1046, arrow_varcharin());
@@ -257,126 +152,48 @@ RegisterExec(1050, arrow_bpcharle());
 RegisterExec(1051, arrow_bpchargt());
 RegisterExec(1052, arrow_bpcharge());
 RegisterExec(1053, arrow_bpcharne());
-RegisterExec(1062, arrow_aclitem_eq());
 RegisterExec(1063, arrow_bpchar_larger());
 RegisterExec(1064, arrow_bpchar_smaller());
 RegisterExec(1078, arrow_bpcharcmp());
 RegisterExec(1080, arrow_hashbpchar());
-RegisterExec(1146, arrow_circle_add_pt());
-RegisterExec(1147, arrow_circle_sub_pt());
-RegisterExec(1148, arrow_circle_mul_pt());
-RegisterExec(1149, arrow_circle_div_pt());
-RegisterExec(1173, arrow_network_subset_support());
-RegisterExec(1193, arrow_array_fill());
-RegisterExec(1264, arrow_PG_char_to_encoding());
-RegisterExec(1267, arrow_cidr_in());
-RegisterExec(1282, arrow_quote_ident());
-RegisterExec(1283, arrow_quote_literal());
-RegisterExec(1286, arrow_array_fill_with_lower_bounds());
-RegisterExec(1289, arrow_quote_nullable());
+RegisterExec(1136, arrow_pg_stat_get_wal());
+RegisterExec(1137, arrow_pg_get_wal_replay_pause_state());
+RegisterExec(1181, arrow_xid_age());
+RegisterExec(1194, arrow_dlog10());
+RegisterExec(1339, arrow_dlog10());
+RegisterExec(1340, arrow_dlog10());
+RegisterExec(1291, arrow_suppress_redundant_updates_trigger());
 RegisterExec(1318, arrow_bpcharlen());
 RegisterExec(1367, arrow_bpcharlen());
 RegisterExec(1372, arrow_bpcharlen());
-RegisterExec(1362, arrow_network_hostmask());
-RegisterExec(1365, arrow_makeaclitem());
 RegisterExec(1375, arrow_bpcharoctetlen());
-RegisterExec(1412, arrow_line_parallel());
-RegisterExec(1496, arrow_line_parallel());
-RegisterExec(1413, arrow_line_perp());
-RegisterExec(1497, arrow_line_perp());
-RegisterExec(1414, arrow_line_vertical());
-RegisterExec(1498, arrow_line_vertical());
-RegisterExec(1415, arrow_line_horizontal());
-RegisterExec(1499, arrow_line_horizontal());
-RegisterExec(1416, arrow_circle_center());
-RegisterExec(1472, arrow_circle_center());
-RegisterExec(1543, arrow_circle_center());
-RegisterExec(1421, arrow_points_box());
-RegisterExec(1422, arrow_box_add());
-RegisterExec(1423, arrow_box_sub());
-RegisterExec(1424, arrow_box_mul());
-RegisterExec(1425, arrow_box_div());
-RegisterExec(1427, arrow_cidr_out());
-RegisterExec(1428, arrow_poly_contain_pt());
-RegisterExec(1429, arrow_pt_contained_poly());
-RegisterExec(1430, arrow_path_isclosed());
-RegisterExec(1431, arrow_path_isopen());
-RegisterExec(1432, arrow_path_npoints());
-RegisterExec(1545, arrow_path_npoints());
-RegisterExec(1433, arrow_path_close());
-RegisterExec(1434, arrow_path_open());
-RegisterExec(1435, arrow_path_add());
-RegisterExec(1436, arrow_path_add_pt());
-RegisterExec(1437, arrow_path_sub_pt());
-RegisterExec(1438, arrow_path_mul_pt());
-RegisterExec(1439, arrow_path_div_pt());
-RegisterExec(1440, arrow_construct_point());
-RegisterExec(1441, arrow_point_add());
-RegisterExec(1442, arrow_point_sub());
-RegisterExec(1443, arrow_point_mul());
-RegisterExec(1444, arrow_point_div());
-RegisterExec(1445, arrow_poly_npoints());
-RegisterExec(1556, arrow_poly_npoints());
-RegisterExec(1446, arrow_poly_box());
-RegisterExec(1447, arrow_poly_path());
-RegisterExec(1448, arrow_box_poly());
-RegisterExec(1449, arrow_path_poly());
-RegisterExec(1450, arrow_circle_in());
-RegisterExec(1451, arrow_circle_out());
-RegisterExec(1452, arrow_circle_same());
-RegisterExec(1453, arrow_circle_contain());
-RegisterExec(1454, arrow_circle_left());
-RegisterExec(1455, arrow_circle_overleft());
-RegisterExec(1456, arrow_circle_overright());
-RegisterExec(1457, arrow_circle_right());
-RegisterExec(1458, arrow_circle_contained());
-RegisterExec(1459, arrow_circle_overlap());
-RegisterExec(1460, arrow_circle_below());
-RegisterExec(1461, arrow_circle_above());
-RegisterExec(1462, arrow_circle_eq());
-RegisterExec(1463, arrow_circle_ne());
-RegisterExec(1464, arrow_circle_lt());
-RegisterExec(1465, arrow_circle_gt());
-RegisterExec(1466, arrow_circle_le());
-RegisterExec(1467, arrow_circle_ge());
-RegisterExec(1468, arrow_circle_area());
-RegisterExec(1469, arrow_circle_diameter());
-RegisterExec(1470, arrow_circle_radius());
-RegisterExec(1471, arrow_circle_distance());
-RegisterExec(1473, arrow_cr_circle());
-RegisterExec(1474, arrow_poly_circle());
-RegisterExec(1475, arrow_circle_poly());
-RegisterExec(1476, arrow_dist_pc());
-RegisterExec(1477, arrow_circle_contain_pt());
-RegisterExec(1478, arrow_pt_contained_circle());
-RegisterExec(1479, arrow_box_circle());
-RegisterExec(1480, arrow_circle_box());
-RegisterExec(1482, arrow_lseg_ne());
-RegisterExec(1483, arrow_lseg_lt());
-RegisterExec(1484, arrow_lseg_le());
-RegisterExec(1485, arrow_lseg_gt());
-RegisterExec(1486, arrow_lseg_ge());
-RegisterExec(1487, arrow_lseg_length());
-RegisterExec(1530, arrow_lseg_length());
-RegisterExec(1488, arrow_close_ls());
-RegisterExec(1489, arrow_close_lseg());
-RegisterExec(1490, arrow_line_in());
-RegisterExec(1491, arrow_line_out());
-RegisterExec(1492, arrow_line_eq());
-RegisterExec(1493, arrow_line_construct_pp());
-RegisterExec(1494, arrow_line_interpt());
-RegisterExec(1495, arrow_line_intersect());
-RegisterExec(1597, arrow_PG_encoding_to_char());
-RegisterExec(1620, arrow_ascii());
-RegisterExec(1621, arrow_chr());
-RegisterExec(1622, arrow_repeat());
-RegisterExec(1633, arrow_texticlike());
-RegisterExec(1660, arrow_texticlike());
-RegisterExec(1634, arrow_texticnlike());
-RegisterExec(1661, arrow_texticnlike());
-RegisterExec(1635, arrow_nameiclike());
-RegisterExec(1636, arrow_nameicnlike());
-RegisterExec(1637, arrow_like_escape());
+RegisterExec(1387, arrow_pg_get_constraintdef());
+RegisterExec(1391, arrow_pg_stat_get_backend_start());
+RegisterExec(1392, arrow_pg_stat_get_backend_client_addr());
+RegisterExec(1393, arrow_pg_stat_get_backend_client_port());
+RegisterExec(1402, arrow_current_schema());
+RegisterExec(1403, arrow_current_schemas());
+RegisterExec(1573, arrow_pg_get_ruledef());
+RegisterExec(1574, arrow_nextval_oid());
+RegisterExec(1575, arrow_currval_oid());
+RegisterExec(1576, arrow_setval_oid());
+RegisterExec(1598, arrow_drandom());
+RegisterExec(1599, arrow_setseed());
+RegisterExec(1600, arrow_dasin());
+RegisterExec(1601, arrow_dacos());
+RegisterExec(1602, arrow_datan());
+RegisterExec(1603, arrow_datan2());
+RegisterExec(1604, arrow_dsin());
+RegisterExec(1605, arrow_dcos());
+RegisterExec(1606, arrow_dtan());
+RegisterExec(1607, arrow_dcot());
+RegisterExec(1608, arrow_degrees());
+RegisterExec(1609, arrow_radians());
+RegisterExec(1610, arrow_dpi());
+RegisterExec(1640, arrow_pg_get_viewdef_name());
+RegisterExec(1641, arrow_pg_get_viewdef());
+RegisterExec(1642, arrow_pg_get_userbyid());
+RegisterExec(1643, arrow_pg_get_indexdef());
 RegisterExec(1644, arrow_RI_FKey_check_ins());
 RegisterExec(1645, arrow_RI_FKey_check_upd());
 RegisterExec(1646, arrow_RI_FKey_cascade_del());
@@ -389,331 +206,325 @@ RegisterExec(1652, arrow_RI_FKey_setdefault_del());
 RegisterExec(1653, arrow_RI_FKey_setdefault_upd());
 RegisterExec(1654, arrow_RI_FKey_noaction_del());
 RegisterExec(1655, arrow_RI_FKey_noaction_upd());
-RegisterExec(1693, arrow_btboolcmp());
-RegisterExec(1713, arrow_length_in_encoding());
-RegisterExec(1714, arrow_pg_convert_from());
-RegisterExec(1715, arrow_inet_to_cidr());
-RegisterExec(1717, arrow_pg_convert_to());
-RegisterExec(1768, arrow_interval_to_char());
-RegisterExec(1770, arrow_timestamptz_to_char());
-RegisterExec(1772, arrow_numeric_to_char());
-RegisterExec(1773, arrow_int4_to_char());
-RegisterExec(1774, arrow_int8_to_char());
-RegisterExec(1775, arrow_float4_to_char());
-RegisterExec(1776, arrow_float8_to_char());
-RegisterExec(1777, arrow_numeric_to_number());
-RegisterExec(1778, arrow_to_timestamp());
-RegisterExec(1780, arrow_to_date());
-RegisterExec(1813, arrow_pg_convert());
-RegisterExec(1922, arrow_has_table_privilege_name_name());
-RegisterExec(1923, arrow_has_table_privilege_name_id());
-RegisterExec(1924, arrow_has_table_privilege_id_name());
-RegisterExec(1925, arrow_has_table_privilege_id_id());
-RegisterExec(1926, arrow_has_table_privilege_name());
-RegisterExec(1927, arrow_has_table_privilege_id());
-RegisterExec(1946, arrow_binary_encode());
-RegisterExec(1947, arrow_binary_decode());
-RegisterExec(2005, arrow_bytealike());
-RegisterExec(2007, arrow_bytealike());
-RegisterExec(2006, arrow_byteanlike());
-RegisterExec(2008, arrow_byteanlike());
-RegisterExec(2009, arrow_like_escape_bytea());
-RegisterExec(2015, arrow_byteatrim());
-RegisterExec(2049, arrow_timestamp_to_char());
-RegisterExec(2077, arrow_show_config_by_name());
-RegisterExec(2078, arrow_set_config_by_name());
-RegisterExec(2091, arrow_array_lower());
-RegisterExec(2092, arrow_array_upper());
+RegisterExec(1662, arrow_pg_get_triggerdef());
+RegisterExec(1665, arrow_pg_get_serial_sequence());
+RegisterExec(1716, arrow_pg_get_expr());
+RegisterExec(1765, arrow_setval3_oid());
+RegisterExec(1830, arrow_float8_avg());
+RegisterExec(1831, arrow_float8_var_samp());
+RegisterExec(1832, arrow_float8_stddev_samp());
+RegisterExec(1913, arrow_float4up());
+RegisterExec(1914, arrow_float8up());
+RegisterExec(1928, arrow_pg_stat_get_numscans());
+RegisterExec(1929, arrow_pg_stat_get_tuples_returned());
+RegisterExec(1930, arrow_pg_stat_get_tuples_fetched());
+RegisterExec(1931, arrow_pg_stat_get_tuples_inserted());
+RegisterExec(1932, arrow_pg_stat_get_tuples_updated());
+RegisterExec(1933, arrow_pg_stat_get_tuples_deleted());
+RegisterExec(1934, arrow_pg_stat_get_blocks_fetched());
+RegisterExec(1935, arrow_pg_stat_get_blocks_hit());
+RegisterExec(1937, arrow_pg_stat_get_backend_pid());
+RegisterExec(1938, arrow_pg_stat_get_backend_dbid());
+RegisterExec(1939, arrow_pg_stat_get_backend_userid());
+RegisterExec(1940, arrow_pg_stat_get_backend_activity());
+RegisterExec(1941, arrow_pg_stat_get_db_numbackends());
+RegisterExec(1942, arrow_pg_stat_get_db_xact_commit());
+RegisterExec(1943, arrow_pg_stat_get_db_xact_rollback());
+RegisterExec(1944, arrow_pg_stat_get_db_blocks_fetched());
+RegisterExec(1945, arrow_pg_stat_get_db_blocks_hit());
+RegisterExec(1972, arrow_pg_stat_get_tuples_hot_updated());
+RegisterExec(2026, arrow_pg_backend_pid());
+RegisterExec(2079, arrow_pg_table_is_visible());
+RegisterExec(2080, arrow_pg_type_is_visible());
+RegisterExec(2081, arrow_pg_function_is_visible());
+RegisterExec(2082, arrow_pg_operator_is_visible());
+RegisterExec(2083, arrow_pg_opclass_is_visible());
+RegisterExec(2093, arrow_pg_conversion_is_visible());
+RegisterExec(2094, arrow_pg_stat_get_backend_activity_start());
+RegisterExec(2098, arrow_pg_get_functiondef());
+RegisterExec(2162, arrow_pg_get_function_arguments());
+RegisterExec(2165, arrow_pg_get_function_result());
+RegisterExec(2168, arrow_pg_database_size_name());
+RegisterExec(2172, arrow_pg_start_backup());
+RegisterExec(2173, arrow_pg_stop_backup());
 RegisterExec(2174, arrow_bpchar_pattern_lt());
 RegisterExec(2175, arrow_bpchar_pattern_le());
-RegisterExec(2176, arrow_array_length());
 RegisterExec(2177, arrow_bpchar_pattern_ge());
 RegisterExec(2178, arrow_bpchar_pattern_gt());
 RegisterExec(2179, arrow_gist_point_consistent());
 RegisterExec(2180, arrow_btbpchar_pattern_cmp());
-RegisterExec(2181, arrow_has_sequence_privilege_name_name());
-RegisterExec(2182, arrow_has_sequence_privilege_name_id());
-RegisterExec(2183, arrow_has_sequence_privilege_id_name());
-RegisterExec(2184, arrow_has_sequence_privilege_id_id());
-RegisterExec(2185, arrow_has_sequence_privilege_name());
-RegisterExec(2186, arrow_has_sequence_privilege_id());
-RegisterExec(2188, arrow_btint48cmp());
-RegisterExec(2189, arrow_btint84cmp());
-RegisterExec(2190, arrow_btint24cmp());
-RegisterExec(2191, arrow_btint42cmp());
-RegisterExec(2192, arrow_btint28cmp());
-RegisterExec(2193, arrow_btint82cmp());
-RegisterExec(2196, arrow_inet_client_addr());
-RegisterExec(2197, arrow_inet_client_port());
-RegisterExec(2198, arrow_inet_server_addr());
-RegisterExec(2199, arrow_inet_server_port());
-RegisterExec(2246, arrow_fmgr_internal_validator());
-RegisterExec(2247, arrow_fmgr_c_validator());
-RegisterExec(2248, arrow_fmgr_sql_validator());
-RegisterExec(2250, arrow_has_database_privilege_name_name());
-RegisterExec(2251, arrow_has_database_privilege_name_id());
-RegisterExec(2252, arrow_has_database_privilege_id_name());
-RegisterExec(2253, arrow_has_database_privilege_id_id());
-RegisterExec(2254, arrow_has_database_privilege_name());
-RegisterExec(2255, arrow_has_database_privilege_id());
-RegisterExec(2256, arrow_has_function_privilege_name_name());
-RegisterExec(2257, arrow_has_function_privilege_name_id());
-RegisterExec(2258, arrow_has_function_privilege_id_name());
-RegisterExec(2259, arrow_has_function_privilege_id_id());
-RegisterExec(2260, arrow_has_function_privilege_name());
-RegisterExec(2261, arrow_has_function_privilege_id());
-RegisterExec(2262, arrow_has_language_privilege_name_name());
-RegisterExec(2263, arrow_has_language_privilege_name_id());
-RegisterExec(2264, arrow_has_language_privilege_id_name());
-RegisterExec(2265, arrow_has_language_privilege_id_id());
-RegisterExec(2266, arrow_has_language_privilege_name());
-RegisterExec(2267, arrow_has_language_privilege_id());
-RegisterExec(2268, arrow_has_schema_privilege_name_name());
-RegisterExec(2269, arrow_has_schema_privilege_name_id());
-RegisterExec(2270, arrow_has_schema_privilege_id_name());
-RegisterExec(2271, arrow_has_schema_privilege_id_id());
-RegisterExec(2272, arrow_has_schema_privilege_name());
-RegisterExec(2273, arrow_has_schema_privilege_id());
-RegisterExec(2311, arrow_md5_text());
-RegisterExec(2319, arrow_pg_encoding_max_length_sql());
-RegisterExec(2321, arrow_md5_bytea());
-RegisterExec(2333, arrow_array_agg_transfn());
-RegisterExec(2334, arrow_array_agg_finalfn());
-RegisterExec(2390, arrow_has_tablespace_privilege_name_name());
-RegisterExec(2391, arrow_has_tablespace_privilege_name_id());
-RegisterExec(2392, arrow_has_tablespace_privilege_id_name());
-RegisterExec(2393, arrow_has_tablespace_privilege_id_id());
-RegisterExec(2394, arrow_has_tablespace_privilege_name());
-RegisterExec(2395, arrow_has_tablespace_privilege_id());
-RegisterExec(2400, arrow_array_recv());
-RegisterExec(2401, arrow_array_send());
-RegisterExec(2428, arrow_point_recv());
-RegisterExec(2429, arrow_point_send());
+RegisterExec(2194, arrow_btfloat48cmp());
+RegisterExec(2195, arrow_btfloat84cmp());
+RegisterExec(2230, arrow_pg_stat_clear_snapshot());
+RegisterExec(2232, arrow_pg_get_function_identity_arguments());
+RegisterExec(2274, arrow_pg_stat_reset());
+RegisterExec(2286, arrow_pg_total_relation_size());
+RegisterExec(2288, arrow_pg_size_pretty());
+RegisterExec(2290, arrow_record_in());
+RegisterExec(2291, arrow_record_out());
+RegisterExec(2292, arrow_cstring_in());
+RegisterExec(2293, arrow_cstring_out());
+RegisterExec(2294, arrow_any_in());
+RegisterExec(2295, arrow_any_out());
+RegisterExec(2296, arrow_anyarray_in());
+RegisterExec(2297, arrow_anyarray_out());
+RegisterExec(2298, arrow_void_in());
+RegisterExec(2299, arrow_void_out());
+RegisterExec(2300, arrow_trigger_in());
+RegisterExec(2301, arrow_trigger_out());
+RegisterExec(2302, arrow_language_handler_in());
+RegisterExec(2303, arrow_language_handler_out());
+RegisterExec(2304, arrow_internal_in());
+RegisterExec(2305, arrow_internal_out());
+RegisterExec(2307, arrow_pg_stat_reset_slru());
+RegisterExec(2308, arrow_dceil());
+RegisterExec(2320, arrow_dceil());
+RegisterExec(2309, arrow_dfloor());
+RegisterExec(2310, arrow_dsign());
+RegisterExec(2312, arrow_anyelement_in());
+RegisterExec(2313, arrow_anyelement_out());
+RegisterExec(2322, arrow_pg_tablespace_size_oid());
+RegisterExec(2323, arrow_pg_tablespace_size_name());
+RegisterExec(2324, arrow_pg_database_size_oid());
+RegisterExec(2332, arrow_pg_relation_size());
+RegisterExec(2398, arrow_shell_in());
+RegisterExec(2399, arrow_shell_out());
+RegisterExec(2402, arrow_record_recv());
+RegisterExec(2403, arrow_record_send());
+RegisterExec(2422, arrow_namerecv());
+RegisterExec(2423, arrow_namesend());
+RegisterExec(2424, arrow_float4recv());
+RegisterExec(2425, arrow_float4send());
+RegisterExec(2426, arrow_float8recv());
+RegisterExec(2427, arrow_float8send());
 RegisterExec(2430, arrow_bpcharrecv());
 RegisterExec(2431, arrow_bpcharsend());
 RegisterExec(2432, arrow_varcharrecv());
 RegisterExec(2433, arrow_varcharsend());
-RegisterExec(2480, arrow_lseg_recv());
-RegisterExec(2481, arrow_lseg_send());
-RegisterExec(2482, arrow_path_recv());
-RegisterExec(2483, arrow_path_send());
-RegisterExec(2484, arrow_box_recv());
-RegisterExec(2485, arrow_box_send());
-RegisterExec(2486, arrow_poly_recv());
-RegisterExec(2487, arrow_poly_send());
-RegisterExec(2488, arrow_line_recv());
-RegisterExec(2489, arrow_line_send());
-RegisterExec(2490, arrow_circle_recv());
-RegisterExec(2491, arrow_circle_send());
-RegisterExec(2496, arrow_inet_recv());
-RegisterExec(2497, arrow_inet_send());
-RegisterExec(2498, arrow_cidr_recv());
-RegisterExec(2499, arrow_cidr_send());
-RegisterExec(2562, arrow_box_below());
-RegisterExec(2563, arrow_box_overbelow());
-RegisterExec(2564, arrow_box_overabove());
-RegisterExec(2565, arrow_box_above());
-RegisterExec(2566, arrow_poly_below());
-RegisterExec(2567, arrow_poly_overbelow());
-RegisterExec(2568, arrow_poly_overabove());
-RegisterExec(2569, arrow_poly_above());
+RegisterExec(2440, arrow_xidrecv());
+RegisterExec(2441, arrow_xidsend());
+RegisterExec(2442, arrow_cidrecv());
+RegisterExec(2443, arrow_cidsend());
+RegisterExec(2462, arrow_dsinh());
+RegisterExec(2463, arrow_dcosh());
+RegisterExec(2464, arrow_dtanh());
+RegisterExec(2465, arrow_dasinh());
+RegisterExec(2466, arrow_dacosh());
+RegisterExec(2467, arrow_datanh());
+RegisterExec(2494, arrow_macaddr_recv());
+RegisterExec(2495, arrow_macaddr_send());
+RegisterExec(2500, arrow_cstring_recv());
+RegisterExec(2501, arrow_cstring_send());
+RegisterExec(2502, arrow_anyarray_recv());
+RegisterExec(2503, arrow_anyarray_send());
+RegisterExec(2504, arrow_pg_get_ruledef_ext());
+RegisterExec(2505, arrow_pg_get_viewdef_name_ext());
+RegisterExec(2506, arrow_pg_get_viewdef_ext());
+RegisterExec(2507, arrow_pg_get_indexdef_ext());
+RegisterExec(2508, arrow_pg_get_constraintdef_ext());
+RegisterExec(2509, arrow_pg_get_expr_ext());
+RegisterExec(2512, arrow_float8_var_pop());
+RegisterExec(2513, arrow_float8_stddev_pop());
+RegisterExec(2559, arrow_lastval());
 RegisterExec(2578, arrow_gist_box_consistent());
-RegisterExec(2580, arrow_jsonb_float8());
 RegisterExec(2581, arrow_gist_box_penalty());
 RegisterExec(2582, arrow_gist_box_picksplit());
 RegisterExec(2583, arrow_gist_box_union());
 RegisterExec(2584, arrow_gist_box_same());
 RegisterExec(2585, arrow_gist_poly_consistent());
 RegisterExec(2586, arrow_gist_poly_compress());
-RegisterExec(2587, arrow_circle_overbelow());
-RegisterExec(2588, arrow_circle_overabove());
 RegisterExec(2591, arrow_gist_circle_consistent());
 RegisterExec(2592, arrow_gist_circle_compress());
-RegisterExec(2627, arrow_inetnot());
-RegisterExec(2628, arrow_inetand());
-RegisterExec(2629, arrow_inetor());
-RegisterExec(2630, arrow_inetpl());
-RegisterExec(2632, arrow_inetmi_int8());
-RegisterExec(2633, arrow_inetmi());
-RegisterExec(2700, arrow_gin_cmp_prefix());
-RegisterExec(2705, arrow_pg_has_role_name_name());
-RegisterExec(2706, arrow_pg_has_role_name_id());
-RegisterExec(2707, arrow_pg_has_role_id_name());
-RegisterExec(2708, arrow_pg_has_role_id_id());
-RegisterExec(2709, arrow_pg_has_role_name());
-RegisterExec(2710, arrow_pg_has_role_id());
-RegisterExec(2747, arrow_arrayoverlap());
-RegisterExec(2748, arrow_arraycontains());
-RegisterExec(2749, arrow_arraycontained());
+RegisterExec(2597, arrow_domain_in());
+RegisterExec(2598, arrow_domain_recv());
+RegisterExec(2730, arrow_pg_get_triggerdef_ext());
+RegisterExec(2731, arrow_dasind());
+RegisterExec(2732, arrow_dacosd());
+RegisterExec(2733, arrow_datand());
+RegisterExec(2734, arrow_datan2d());
+RegisterExec(2735, arrow_dsind());
+RegisterExec(2736, arrow_dcosd());
+RegisterExec(2737, arrow_dtand());
+RegisterExec(2738, arrow_dcotd());
+RegisterExec(2758, arrow_pg_stat_get_db_tuples_returned());
+RegisterExec(2759, arrow_pg_stat_get_db_tuples_fetched());
+RegisterExec(2760, arrow_pg_stat_get_db_tuples_inserted());
+RegisterExec(2761, arrow_pg_stat_get_db_tuples_updated());
+RegisterExec(2762, arrow_pg_stat_get_db_tuples_deleted());
+RegisterExec(2769, arrow_pg_stat_get_bgwriter_timed_checkpoints());
+RegisterExec(2770, arrow_pg_stat_get_bgwriter_requested_checkpoints());
+RegisterExec(2771, arrow_pg_stat_get_bgwriter_buf_written_checkpoints());
+RegisterExec(2772, arrow_pg_stat_get_bgwriter_buf_written_clean());
+RegisterExec(2773, arrow_pg_stat_get_bgwriter_maxwritten_clean());
+RegisterExec(2775, arrow_pg_stat_get_buf_written_backend());
+RegisterExec(2777, arrow_anynonarray_in());
+RegisterExec(2778, arrow_anynonarray_out());
+RegisterExec(2781, arrow_pg_stat_get_last_vacuum_time());
+RegisterExec(2782, arrow_pg_stat_get_last_autovacuum_time());
+RegisterExec(2783, arrow_pg_stat_get_last_analyze_time());
+RegisterExec(2784, arrow_pg_stat_get_last_autoanalyze_time());
+RegisterExec(2788, arrow_pg_stat_get_backend_wait_event_type());
+RegisterExec(2806, arrow_float8_regr_accum());
+RegisterExec(2807, arrow_float8_regr_sxx());
+RegisterExec(2808, arrow_float8_regr_syy());
+RegisterExec(2809, arrow_float8_regr_sxy());
+RegisterExec(2810, arrow_float8_regr_avgx());
+RegisterExec(2811, arrow_float8_regr_avgy());
+RegisterExec(2812, arrow_float8_regr_r2());
+RegisterExec(2813, arrow_float8_regr_slope());
+RegisterExec(2814, arrow_float8_regr_intercept());
+RegisterExec(2815, arrow_float8_covar_pop());
+RegisterExec(2816, arrow_float8_covar_samp());
+RegisterExec(2817, arrow_float8_corr());
+RegisterExec(2844, arrow_pg_stat_get_db_blk_read_time());
+RegisterExec(2845, arrow_pg_stat_get_db_blk_write_time());
+RegisterExec(2848, arrow_pg_switch_wal());
+RegisterExec(2849, arrow_pg_current_wal_lsn());
+RegisterExec(2850, arrow_pg_walfile_name_offset());
+RegisterExec(2851, arrow_pg_walfile_name());
+RegisterExec(2852, arrow_pg_current_wal_insert_lsn());
+RegisterExec(2853, arrow_pg_stat_get_backend_wait_event());
+RegisterExec(2854, arrow_pg_my_temp_schema());
+RegisterExec(2855, arrow_pg_is_other_temp_schema());
+RegisterExec(2857, arrow_pg_stat_get_backend_xact_start());
+RegisterExec(2859, arrow_pg_stat_get_buf_alloc());
+RegisterExec(2878, arrow_pg_stat_get_live_tuples());
+RegisterExec(2879, arrow_pg_stat_get_dead_tuples());
 RegisterExec(2913, arrow_bpchartypmodin());
 RegisterExec(2914, arrow_bpchartypmodout());
 RegisterExec(2915, arrow_varchartypmodin());
 RegisterExec(2916, arrow_varchartypmodout());
-RegisterExec(2952, arrow_uuid_in());
-RegisterExec(2953, arrow_uuid_out());
-RegisterExec(2954, arrow_uuid_lt());
-RegisterExec(2955, arrow_uuid_le());
-RegisterExec(2956, arrow_uuid_eq());
-RegisterExec(2957, arrow_uuid_ge());
-RegisterExec(2958, arrow_uuid_gt());
-RegisterExec(2959, arrow_uuid_ne());
-RegisterExec(2960, arrow_uuid_cmp());
-RegisterExec(2961, arrow_uuid_recv());
-RegisterExec(2962, arrow_uuid_send());
-RegisterExec(2963, arrow_uuid_hash());
-RegisterExec(3000, arrow_has_foreign_data_wrapper_privilege_name_name());
-RegisterExec(3001, arrow_has_foreign_data_wrapper_privilege_name_id());
-RegisterExec(3002, arrow_has_foreign_data_wrapper_privilege_id_name());
-RegisterExec(3003, arrow_has_foreign_data_wrapper_privilege_id_id());
-RegisterExec(3004, arrow_has_foreign_data_wrapper_privilege_name());
-RegisterExec(3005, arrow_has_foreign_data_wrapper_privilege_id());
-RegisterExec(3006, arrow_has_server_privilege_name_name());
-RegisterExec(3007, arrow_has_server_privilege_name_id());
-RegisterExec(3008, arrow_has_server_privilege_id_name());
-RegisterExec(3009, arrow_has_server_privilege_id_id());
-RegisterExec(3010, arrow_has_server_privilege_name());
-RegisterExec(3011, arrow_has_server_privilege_id());
-RegisterExec(3012, arrow_has_column_privilege_name_name_name());
-RegisterExec(3013, arrow_has_column_privilege_name_name_attnum());
-RegisterExec(3014, arrow_has_column_privilege_name_id_name());
-RegisterExec(3015, arrow_has_column_privilege_name_id_attnum());
-RegisterExec(3016, arrow_has_column_privilege_id_name_name());
-RegisterExec(3017, arrow_has_column_privilege_id_name_attnum());
-RegisterExec(3018, arrow_has_column_privilege_id_id_name());
-RegisterExec(3019, arrow_has_column_privilege_id_id_attnum());
-RegisterExec(3020, arrow_has_column_privilege_name_name());
-RegisterExec(3021, arrow_has_column_privilege_name_attnum());
-RegisterExec(3022, arrow_has_column_privilege_id_name());
-RegisterExec(3023, arrow_has_column_privilege_id_attnum());
-RegisterExec(3024, arrow_has_any_column_privilege_name_name());
-RegisterExec(3025, arrow_has_any_column_privilege_name_id());
-RegisterExec(3026, arrow_has_any_column_privilege_id_name());
-RegisterExec(3027, arrow_has_any_column_privilege_id_id());
-RegisterExec(3028, arrow_has_any_column_privilege_name());
-RegisterExec(3029, arrow_has_any_column_privilege_id());
+RegisterExec(2978, arrow_pg_stat_get_function_calls());
+RegisterExec(2979, arrow_pg_stat_get_function_total_time());
+RegisterExec(2980, arrow_pg_stat_get_function_self_time());
+RegisterExec(2981, arrow_record_eq());
+RegisterExec(2982, arrow_record_ne());
+RegisterExec(2983, arrow_record_lt());
+RegisterExec(2984, arrow_record_gt());
+RegisterExec(2985, arrow_record_le());
+RegisterExec(2986, arrow_record_ge());
+RegisterExec(2987, arrow_btrecordcmp());
+RegisterExec(2997, arrow_pg_table_size());
+RegisterExec(2998, arrow_pg_indexes_size());
+RegisterExec(2999, arrow_pg_relation_filenode());
+RegisterExec(3034, arrow_pg_relation_filepath());
+RegisterExec(3037, arrow_pg_stat_get_xact_numscans());
+RegisterExec(3038, arrow_pg_stat_get_xact_tuples_returned());
+RegisterExec(3039, arrow_pg_stat_get_xact_tuples_fetched());
+RegisterExec(3040, arrow_pg_stat_get_xact_tuples_inserted());
+RegisterExec(3041, arrow_pg_stat_get_xact_tuples_updated());
+RegisterExec(3042, arrow_pg_stat_get_xact_tuples_deleted());
+RegisterExec(3043, arrow_pg_stat_get_xact_tuples_hot_updated());
+RegisterExec(3044, arrow_pg_stat_get_xact_blocks_fetched());
+RegisterExec(3045, arrow_pg_stat_get_xact_blocks_hit());
+RegisterExec(3046, arrow_pg_stat_get_xact_function_calls());
+RegisterExec(3047, arrow_pg_stat_get_xact_function_total_time());
+RegisterExec(3048, arrow_pg_stat_get_xact_function_self_time());
+RegisterExec(3054, arrow_pg_stat_get_vacuum_count());
+RegisterExec(3055, arrow_pg_stat_get_autovacuum_count());
+RegisterExec(3056, arrow_pg_stat_get_analyze_count());
+RegisterExec(3057, arrow_pg_stat_get_autoanalyze_count());
+RegisterExec(3063, arrow_pg_stat_get_buf_fsync_backend());
 RegisterExec(3064, arrow_gist_point_distance());
-RegisterExec(3077, arrow_gin_extract_tsvector_2args());
+RegisterExec(3065, arrow_pg_stat_get_db_conflict_tablespace());
+RegisterExec(3066, arrow_pg_stat_get_db_conflict_lock());
+RegisterExec(3067, arrow_pg_stat_get_db_conflict_snapshot());
+RegisterExec(3068, arrow_pg_stat_get_db_conflict_bufferpin());
+RegisterExec(3069, arrow_pg_stat_get_db_conflict_startup_deadlock());
+RegisterExec(3070, arrow_pg_stat_get_db_conflict_all());
+RegisterExec(3071, arrow_pg_wal_replay_pause());
+RegisterExec(3072, arrow_pg_wal_replay_resume());
+RegisterExec(3073, arrow_pg_is_wal_replay_paused());
+RegisterExec(3074, arrow_pg_stat_get_db_stat_reset_time());
+RegisterExec(3075, arrow_pg_stat_get_bgwriter_stat_reset_time());
+RegisterExec(3078, arrow_pg_sequence_parameters());
 RegisterExec(3086, arrow_pg_extension_config_dump());
-RegisterExec(3087, arrow_gin_extract_tsquery_5args());
-RegisterExec(3088, arrow_gin_tsquery_consistent_6args());
 RegisterExec(3097, arrow_varchar_support());
-RegisterExec(3129, arrow_btint2sortsupport());
-RegisterExec(3130, arrow_btint4sortsupport());
-RegisterExec(3131, arrow_btint8sortsupport());
-RegisterExec(3134, arrow_btoidsortsupport());
-RegisterExec(3138, arrow_has_type_privilege_name_name());
-RegisterExec(3139, arrow_has_type_privilege_name_id());
-RegisterExec(3140, arrow_has_type_privilege_id_name());
-RegisterExec(3141, arrow_has_type_privilege_id_id());
-RegisterExec(3142, arrow_has_type_privilege_name());
-RegisterExec(3143, arrow_has_type_privilege_id());
-RegisterExec(3153, arrow_array_to_json());
-RegisterExec(3154, arrow_array_to_json_pretty());
-RegisterExec(3155, arrow_row_to_json());
-RegisterExec(3156, arrow_row_to_json_pretty());
+RegisterExec(3098, arrow_pg_create_restore_point());
+RegisterExec(3116, arrow_fdw_handler_in());
+RegisterExec(3117, arrow_fdw_handler_out());
+RegisterExec(3120, arrow_void_recv());
+RegisterExec(3121, arrow_void_send());
+RegisterExec(3132, arrow_btfloat4sortsupport());
+RegisterExec(3133, arrow_btfloat8sortsupport());
+RegisterExec(3135, arrow_btnamesortsupport());
+RegisterExec(3144, arrow_macaddr_not());
+RegisterExec(3145, arrow_macaddr_and());
+RegisterExec(3146, arrow_macaddr_or());
+RegisterExec(3150, arrow_pg_stat_get_db_temp_files());
+RegisterExec(3151, arrow_pg_stat_get_db_temp_bytes());
+RegisterExec(3152, arrow_pg_stat_get_db_deadlocks());
+RegisterExec(3159, arrow_pg_get_viewdef_wrap());
+RegisterExec(3160, arrow_pg_stat_get_checkpoint_write_time());
+RegisterExec(3161, arrow_pg_stat_get_checkpoint_sync_time());
 RegisterExec(3163, arrow_pg_trigger_depth());
-RegisterExec(3167, arrow_array_remove());
-RegisterExec(3168, arrow_array_replace());
-RegisterExec(3173, arrow_json_agg_transfn());
-RegisterExec(3174, arrow_json_agg_finalfn());
-RegisterExec(3176, arrow_to_json());
-RegisterExec(3179, arrow_array_cardinality());
-RegisterExec(3180, arrow_json_object_agg_transfn());
-RegisterExec(3196, arrow_json_object_agg_finalfn());
-RegisterExec(3199, arrow_json_build_array_noargs());
-RegisterExec(3201, arrow_json_build_object_noargs());
-RegisterExec(3202, arrow_json_object());
-RegisterExec(3203, arrow_json_object_two_arg());
-RegisterExec(3210, arrow_jsonb_typeof());
-RegisterExec(3218, arrow_width_bucket_array());
-RegisterExec(3263, arrow_jsonb_object());
-RegisterExec(3264, arrow_jsonb_object_two_arg());
-RegisterExec(3265, arrow_jsonb_agg_transfn());
-RegisterExec(3266, arrow_jsonb_agg_finalfn());
-RegisterExec(3268, arrow_jsonb_object_agg_transfn());
-RegisterExec(3269, arrow_jsonb_object_agg_finalfn());
-RegisterExec(3272, arrow_jsonb_build_array_noargs());
-RegisterExec(3274, arrow_jsonb_build_object_noargs());
-RegisterExec(3275, arrow_dist_ppoly());
-RegisterExec(3277, arrow_array_position());
-RegisterExec(3278, arrow_array_position_start());
-RegisterExec(3279, arrow_array_positions());
+RegisterExec(3165, arrow_pg_wal_lsn_diff());
+RegisterExec(3166, arrow_pg_size_pretty_numeric());
+RegisterExec(3169, arrow_rangesel());
+RegisterExec(3177, arrow_pg_stat_get_mod_since_analyze());
+RegisterExec(3181, arrow_record_image_eq());
+RegisterExec(3182, arrow_record_image_ne());
+RegisterExec(3183, arrow_record_image_lt());
+RegisterExec(3184, arrow_record_image_gt());
+RegisterExec(3185, arrow_record_image_le());
+RegisterExec(3186, arrow_record_image_ge());
+RegisterExec(3187, arrow_btrecordimagecmp());
+RegisterExec(3195, arrow_pg_stat_get_archiver());
+RegisterExec(3229, arrow_pg_lsn_in());
+RegisterExec(3230, arrow_pg_lsn_out());
+RegisterExec(3231, arrow_pg_lsn_lt());
+RegisterExec(3232, arrow_pg_lsn_le());
+RegisterExec(3233, arrow_pg_lsn_eq());
+RegisterExec(3234, arrow_pg_lsn_ge());
+RegisterExec(3235, arrow_pg_lsn_gt());
+RegisterExec(3236, arrow_pg_lsn_ne());
+RegisterExec(3237, arrow_pg_lsn_mi());
+RegisterExec(3238, arrow_pg_lsn_recv());
+RegisterExec(3239, arrow_pg_lsn_send());
+RegisterExec(3251, arrow_pg_lsn_cmp());
+RegisterExec(3252, arrow_pg_lsn_hash());
 RegisterExec(3280, arrow_gist_circle_distance());
 RegisterExec(3282, arrow_gist_point_fetch());
 RegisterExec(3288, arrow_gist_poly_distance());
-RegisterExec(3290, arrow_dist_cpoint());
-RegisterExec(3292, arrow_dist_polyp());
-RegisterExec(3294, arrow_show_config_by_name_missing_ok());
-RegisterExec(3300, arrow_uuid_sortsupport());
-RegisterExec(3319, arrow_tsvector_filter());
-RegisterExec(3320, arrow_tsvector_setweight_by_filter());
-RegisterExec(3321, arrow_tsvector_delete_str());
-RegisterExec(3323, arrow_tsvector_delete_arr());
-RegisterExec(3326, arrow_tsvector_to_array());
-RegisterExec(3327, arrow_array_to_tsvector());
+RegisterExec(3308, arrow_xidneq());
+RegisterExec(3309, arrow_xidneq());
+RegisterExec(3311, arrow_tsm_handler_in());
+RegisterExec(3312, arrow_tsm_handler_out());
+RegisterExec(3314, arrow_tsm_system_handler());
 RegisterExec(3328, arrow_bpchar_sortsupport());
+RegisterExec(3330, arrow_pg_current_wal_flush_lsn());
 RegisterExec(3333, arrow_btbpchar_pattern_sortsupport());
-RegisterExec(3412, arrow_uuid_hash_extended());
-RegisterExec(3414, arrow_hashenumextended());
-RegisterExec(3419, arrow_sha224_bytea());
-RegisterExec(3420, arrow_sha256_bytea());
-RegisterExec(3421, arrow_sha384_bytea());
-RegisterExec(3422, arrow_sha512_bytea());
-RegisterExec(3432, arrow_gen_random_uuid());
+RegisterExec(3334, arrow_pg_size_bytes());
+RegisterExec(3342, arrow_float8_regr_combine());
+RegisterExec(3352, arrow_pg_get_partkeydef());
+RegisterExec(3359, arrow_macaddr_sortsupport());
+RegisterExec(3383, arrow_brin_minmax_opcinfo());
+RegisterExec(3384, arrow_brin_minmax_add_value());
+RegisterExec(3385, arrow_brin_minmax_consistent());
+RegisterExec(3386, arrow_brin_minmax_union());
+RegisterExec(3403, arrow_pg_statistics_obj_is_visible());
+RegisterExec(3408, arrow_pg_get_partition_constraintdef());
+RegisterExec(3413, arrow_pg_lsn_hash_extended());
+RegisterExec(3415, arrow_pg_get_statisticsobjdef());
+RegisterExec(3426, arrow_pg_stat_get_db_checksum_failures());
+RegisterExec(3428, arrow_pg_stat_get_db_checksum_last_failure());
 RegisterExec(3435, arrow_gist_point_sortsupport());
-RegisterExec(3449, arrow_jsonb_numeric());
-RegisterExec(3450, arrow_jsonb_int2());
-RegisterExec(3451, arrow_jsonb_int4());
-RegisterExec(3452, arrow_jsonb_int8());
-RegisterExec(3453, arrow_jsonb_float4());
-RegisterExec(3506, arrow_enum_in());
-RegisterExec(3507, arrow_enum_out());
-RegisterExec(3508, arrow_enum_eq());
-RegisterExec(3509, arrow_enum_ne());
-RegisterExec(3510, arrow_enum_lt());
-RegisterExec(3511, arrow_enum_gt());
-RegisterExec(3512, arrow_enum_le());
-RegisterExec(3513, arrow_enum_ge());
-RegisterExec(3514, arrow_enum_cmp());
-RegisterExec(3515, arrow_hashenum());
-RegisterExec(3524, arrow_enum_smaller());
-RegisterExec(3525, arrow_enum_larger());
-RegisterExec(3528, arrow_enum_first());
-RegisterExec(3529, arrow_enum_last());
-RegisterExec(3530, arrow_enum_range_bounds());
-RegisterExec(3531, arrow_enum_range_all());
-RegisterExec(3532, arrow_enum_recv());
-RegisterExec(3533, arrow_enum_send());
-RegisterExec(3551, arrow_network_overlap());
-RegisterExec(3553, arrow_inet_gist_consistent());
-RegisterExec(3554, arrow_inet_gist_union());
-RegisterExec(3555, arrow_inet_gist_compress());
-RegisterExec(3556, arrow_jsonb_bool());
-RegisterExec(3557, arrow_inet_gist_penalty());
-RegisterExec(3558, arrow_inet_gist_picksplit());
-RegisterExec(3559, arrow_inet_gist_same());
-RegisterExec(3562, arrow_network_larger());
-RegisterExec(3563, arrow_network_smaller());
-RegisterExec(3573, arrow_inet_gist_fetch());
+RegisterExec(3436, arrow_pg_promote());
+RegisterExec(3441, arrow_pg_control_system());
+RegisterExec(3442, arrow_pg_control_checkpoint());
+RegisterExec(3443, arrow_pg_control_recovery());
+RegisterExec(3444, arrow_pg_control_init());
+RegisterExec(3454, arrow_pg_filenode_relation());
+RegisterExec(3504, arrow_anyenum_in());
+RegisterExec(3505, arrow_anyenum_out());
+RegisterExec(3560, arrow_networksel());
+RegisterExec(3561, arrow_networkjoinsel());
+RegisterExec(3594, arrow_event_trigger_in());
+RegisterExec(3595, arrow_event_trigger_out());
 RegisterExec(3610, arrow_tsvectorin());
 RegisterExec(3611, arrow_tsvectorout());
-RegisterExec(3616, arrow_tsvector_lt());
-RegisterExec(3617, arrow_tsvector_le());
-RegisterExec(3618, arrow_tsvector_eq());
-RegisterExec(3619, arrow_tsvector_ne());
-RegisterExec(3620, arrow_tsvector_ge());
-RegisterExec(3621, arrow_tsvector_gt());
-RegisterExec(3622, arrow_tsvector_cmp());
-RegisterExec(3623, arrow_tsvector_strip());
-RegisterExec(3624, arrow_tsvector_setweight());
-RegisterExec(3625, arrow_tsvector_concat());
-RegisterExec(3634, arrow_ts_match_vq());
-RegisterExec(3635, arrow_ts_match_qv());
 RegisterExec(3638, arrow_tsvectorsend());
 RegisterExec(3639, arrow_tsvectorrecv());
-RegisterExec(3656, arrow_gin_extract_tsvector());
-RegisterExec(3657, arrow_gin_extract_tsquery());
-RegisterExec(3658, arrow_gin_tsquery_consistent());
 RegisterExec(3662, arrow_tsquery_lt());
 RegisterExec(3663, arrow_tsquery_le());
 RegisterExec(3664, arrow_tsquery_eq());
@@ -725,45 +536,54 @@ RegisterExec(3669, arrow_tsquery_and());
 RegisterExec(3670, arrow_tsquery_or());
 RegisterExec(3671, arrow_tsquery_not());
 RegisterExec(3672, arrow_tsquery_numnode());
-RegisterExec(3686, arrow_tsmatchsel());
-RegisterExec(3687, arrow_tsmatchjoinsel());
 RegisterExec(3691, arrow_tsq_mcontains());
 RegisterExec(3692, arrow_tsq_mcontained());
-RegisterExec(3711, arrow_tsvector_length());
-RegisterExec(3724, arrow_gin_cmp_tslexeme());
+RegisterExec(3717, arrow_prsd_start());
+RegisterExec(3718, arrow_prsd_nexttoken());
+RegisterExec(3719, arrow_prsd_end());
+RegisterExec(3720, arrow_prsd_headline());
+RegisterExec(3721, arrow_prsd_lextype());
 RegisterExec(3728, arrow_dsynonym_init());
 RegisterExec(3729, arrow_dsynonym_lexize());
 RegisterExec(3731, arrow_dispell_init());
 RegisterExec(3732, arrow_dispell_lexize());
-RegisterExec(3752, arrow_tsvector_update_trigger_byid());
-RegisterExec(3753, arrow_tsvector_update_trigger_bycolumn());
-RegisterExec(3760, arrow_ts_match_tt());
-RegisterExec(3761, arrow_ts_match_tq());
-RegisterExec(3779, arrow_pg_create_physical_replication_slot());
-RegisterExec(3780, arrow_pg_drop_replication_slot());
-RegisterExec(3786, arrow_pg_create_logical_replication_slot());
-RegisterExec(3787, arrow_to_jsonb());
-RegisterExec(3791, arrow_gin_extract_tsquery_oldsig());
-RegisterExec(3792, arrow_gin_tsquery_consistent_oldsig());
-RegisterExec(3795, arrow_inet_spg_config());
-RegisterExec(3796, arrow_inet_spg_choose());
-RegisterExec(3797, arrow_inet_spg_picksplit());
-RegisterExec(3798, arrow_inet_spg_inner_consistent());
-RegisterExec(3799, arrow_inet_spg_leaf_consistent());
-RegisterExec(3803, arrow_jsonb_send());
-RegisterExec(3804, arrow_jsonb_out());
-RegisterExec(3805, arrow_jsonb_recv());
-RegisterExec(3806, arrow_jsonb_in());
-RegisterExec(3878, arrow_pg_replication_slot_advance());
-RegisterExec(3916, arrow_range_typanalyze());
-RegisterExec(3921, arrow_gin_tsquery_triconsistent());
-RegisterExec(3943, arrow_acldefault_sql());
-RegisterExec(3952, arrow_brin_summarize_new_values());
-RegisterExec(3968, arrow_json_typeof());
-RegisterExec(3996, arrow_array_unnest_support());
+RegisterExec(3756, arrow_pg_ts_parser_is_visible());
+RegisterExec(3757, arrow_pg_ts_dict_is_visible());
+RegisterExec(3758, arrow_pg_ts_config_is_visible());
+RegisterExec(3768, arrow_pg_ts_template_is_visible());
+RegisterExec(3775, arrow_pg_stat_reset_shared());
+RegisterExec(3776, arrow_pg_stat_reset_single_table_counters());
+RegisterExec(3777, arrow_pg_stat_reset_single_function_counters());
+RegisterExec(3788, arrow_pg_stat_get_snapshot_timestamp());
+RegisterExec(3789, arrow_gin_clean_pending_list());
+RegisterExec(3808, arrow_pg_get_function_arg_default());
+RegisterExec(3810, arrow_pg_is_in_recovery());
+RegisterExec(3813, arrow_pg_is_in_backup());
+RegisterExec(3814, arrow_pg_backup_start_time());
+RegisterExec(3815, arrow_pg_collation_is_visible());
+RegisterExec(3817, arrow_arraycontsel());
+RegisterExec(3818, arrow_arraycontjoinsel());
+RegisterExec(3820, arrow_pg_last_wal_receive_lsn());
+RegisterExec(3821, arrow_pg_last_wal_replay_lsn());
+RegisterExec(3829, arrow_pg_opfamily_is_visible());
+RegisterExec(3830, arrow_pg_last_xact_replay_timestamp());
+RegisterExec(3832, arrow_anyrange_in());
+RegisterExec(3833, arrow_anyrange_out());
+RegisterExec(3939, arrow_mxid_age());
+RegisterExec(3970, arrow_ordered_set_transition());
+RegisterExec(3973, arrow_percentile_disc_final());
+RegisterExec(3975, arrow_percentile_cont_float8_final());
+RegisterExec(3977, arrow_percentile_cont_interval_final());
+RegisterExec(3979, arrow_percentile_disc_multi_final());
+RegisterExec(3981, arrow_percentile_cont_float8_multi_final());
+RegisterExec(3983, arrow_percentile_cont_interval_multi_final());
+RegisterExec(3985, arrow_mode_final());
 RegisterExec(3998, arrow_gist_box_distance());
-RegisterExec(3999, arrow_brin_summarize_range());
-RegisterExec(4014, arrow_brin_desummarize_range());
+RegisterExec(4018, arrow_spg_quad_config());
+RegisterExec(4019, arrow_spg_quad_choose());
+RegisterExec(4020, arrow_spg_quad_picksplit());
+RegisterExec(4021, arrow_spg_quad_inner_consistent());
+RegisterExec(4022, arrow_spg_quad_leaf_consistent());
 RegisterExec(4023, arrow_spg_kd_config());
 RegisterExec(4024, arrow_spg_kd_choose());
 RegisterExec(4025, arrow_spg_kd_picksplit());
@@ -773,26 +593,119 @@ RegisterExec(4028, arrow_spg_text_choose());
 RegisterExec(4029, arrow_spg_text_picksplit());
 RegisterExec(4030, arrow_spg_text_inner_consistent());
 RegisterExec(4031, arrow_spg_text_leaf_consistent());
-RegisterExec(4051, arrow_array_agg_array_transfn());
-RegisterExec(4052, arrow_array_agg_array_finalfn());
-RegisterExec(4063, arrow_inet_merge());
-RegisterExec(4067, arrow_boxes_bound_box());
-RegisterExec(4071, arrow_inet_same_family());
-RegisterExec(4091, arrow_point_box());
-RegisterExec(4220, arrow_pg_copy_physical_replication_slot_a());
-RegisterExec(4221, arrow_pg_copy_physical_replication_slot_b());
-RegisterExec(4222, arrow_pg_copy_logical_replication_slot_a());
-RegisterExec(4223, arrow_pg_copy_logical_replication_slot_b());
-RegisterExec(4224, arrow_pg_copy_logical_replication_slot_c());
-RegisterExec(4242, arrow_multirange_typanalyze());
-RegisterExec(4566, arrow_pg_event_trigger_table_rewrite_oid());
-RegisterExec(4567, arrow_pg_event_trigger_table_rewrite_reason());
+RegisterExec(4032, arrow_pg_sequence_last_value());
+RegisterExec(4139, arrow_in_range_float8_float8());
+RegisterExec(4140, arrow_in_range_float4_float8());
+RegisterExec(4187, arrow_pg_lsn_larger());
+RegisterExec(4188, arrow_pg_lsn_smaller());
+RegisterExec(4226, arrow_anycompatiblemultirange_in());
+RegisterExec(4227, arrow_anycompatiblemultirange_out());
+RegisterExec(4228, arrow_range_merge_from_multirange());
+RegisterExec(4229, arrow_anymultirange_in());
+RegisterExec(4230, arrow_anymultirange_out());
+RegisterExec(4231, arrow_multirange_in());
+RegisterExec(4232, arrow_multirange_out());
+RegisterExec(4233, arrow_multirange_recv());
+RegisterExec(4234, arrow_multirange_send());
+RegisterExec(4235, arrow_multirange_lower());
+RegisterExec(4236, arrow_multirange_upper());
+RegisterExec(4237, arrow_multirange_empty());
+RegisterExec(4238, arrow_multirange_lower_inc());
+RegisterExec(4239, arrow_multirange_upper_inc());
+RegisterExec(4240, arrow_multirange_lower_inf());
+RegisterExec(4241, arrow_multirange_upper_inf());
+RegisterExec(4243, arrow_multirangesel());
+RegisterExec(4244, arrow_multirange_eq());
+RegisterExec(4245, arrow_multirange_ne());
+RegisterExec(4246, arrow_range_overlaps_multirange());
+RegisterExec(4247, arrow_multirange_overlaps_range());
+RegisterExec(4248, arrow_multirange_overlaps_multirange());
+RegisterExec(4249, arrow_multirange_contains_elem());
+RegisterExec(4250, arrow_multirange_contains_range());
+RegisterExec(4251, arrow_multirange_contains_multirange());
+RegisterExec(4252, arrow_elem_contained_by_multirange());
+RegisterExec(4253, arrow_range_contained_by_multirange());
+RegisterExec(4254, arrow_multirange_contained_by_multirange());
+RegisterExec(4255, arrow_range_adjacent_multirange());
+RegisterExec(4256, arrow_multirange_adjacent_multirange());
+RegisterExec(4257, arrow_multirange_adjacent_range());
+RegisterExec(4258, arrow_range_before_multirange());
+RegisterExec(4259, arrow_multirange_before_range());
+RegisterExec(4260, arrow_multirange_before_multirange());
+RegisterExec(4261, arrow_range_after_multirange());
+RegisterExec(4262, arrow_multirange_after_range());
+RegisterExec(4263, arrow_multirange_after_multirange());
+RegisterExec(4264, arrow_range_overleft_multirange());
+RegisterExec(4265, arrow_multirange_overleft_range());
+RegisterExec(4266, arrow_multirange_overleft_multirange());
+RegisterExec(4267, arrow_range_overright_multirange());
+RegisterExec(4268, arrow_multirange_overright_range());
+RegisterExec(4269, arrow_multirange_overright_multirange());
+RegisterExec(4270, arrow_multirange_union());
+RegisterExec(4271, arrow_multirange_minus());
+RegisterExec(4272, arrow_multirange_intersect());
+RegisterExec(4273, arrow_multirange_cmp());
+RegisterExec(4274, arrow_multirange_lt());
+RegisterExec(4275, arrow_multirange_le());
+RegisterExec(4276, arrow_multirange_ge());
+RegisterExec(4277, arrow_multirange_gt());
+RegisterExec(4278, arrow_hash_multirange());
+RegisterExec(4279, arrow_hash_multirange_extended());
+RegisterExec(4280, arrow_multirange_constructor0());
+RegisterExec(4283, arrow_multirange_constructor0());
+RegisterExec(4286, arrow_multirange_constructor0());
+RegisterExec(4289, arrow_multirange_constructor0());
+RegisterExec(4292, arrow_multirange_constructor0());
+RegisterExec(4295, arrow_multirange_constructor0());
+RegisterExec(4281, arrow_multirange_constructor1());
+RegisterExec(4284, arrow_multirange_constructor1());
+RegisterExec(4287, arrow_multirange_constructor1());
+RegisterExec(4290, arrow_multirange_constructor1());
+RegisterExec(4293, arrow_multirange_constructor1());
+RegisterExec(4296, arrow_multirange_constructor1());
+RegisterExec(4298, arrow_multirange_constructor1());
+RegisterExec(4299, arrow_range_agg_transfn());
+RegisterExec(4300, arrow_range_agg_finalfn());
+RegisterExec(4388, arrow_multirange_intersect_agg_transfn());
+RegisterExec(4541, arrow_range_contains_multirange());
+RegisterExec(4542, arrow_multirange_contained_by_range());
 RegisterExec(5003, arrow_tsquery_phrase());
 RegisterExec(5004, arrow_tsquery_phrase_distance());
-RegisterExec(5033, arrow_network_sortsupport());
-RegisterExec(5040, arrow_matchingsel());
-RegisterExec(5041, arrow_matchingjoinsel());
-RegisterExec(6098, arrow_jsonb_subscript_handler());
-RegisterExec(6172, arrow_trim_array());
-RegisterExec(6195, arrow_bytealtrim());
-RegisterExec(6196, arrow_byteartrim());
+RegisterExec(5022, arrow_pg_lsn_pli());
+RegisterExec(5024, arrow_pg_lsn_mii());
+RegisterExec(5034, arrow_xid8lt());
+RegisterExec(5035, arrow_xid8gt());
+RegisterExec(5036, arrow_xid8le());
+RegisterExec(5037, arrow_xid8ge());
+RegisterExec(5053, arrow_pg_stat_get_ins_since_vacuum());
+RegisterExec(5070, arrow_xid8in());
+RegisterExec(5071, arrow_xid8toxid());
+RegisterExec(5081, arrow_xid8out());
+RegisterExec(5082, arrow_xid8recv());
+RegisterExec(5083, arrow_xid8send());
+RegisterExec(5084, arrow_xid8eq());
+RegisterExec(5085, arrow_xid8ne());
+RegisterExec(5086, arrow_anycompatible_in());
+RegisterExec(5087, arrow_anycompatible_out());
+RegisterExec(5088, arrow_anycompatiblearray_in());
+RegisterExec(5089, arrow_anycompatiblearray_out());
+RegisterExec(5090, arrow_anycompatiblearray_recv());
+RegisterExec(5091, arrow_anycompatiblearray_send());
+RegisterExec(5092, arrow_anycompatiblenonarray_in());
+RegisterExec(5093, arrow_anycompatiblenonarray_out());
+RegisterExec(5094, arrow_anycompatiblerange_in());
+RegisterExec(5095, arrow_anycompatiblerange_out());
+RegisterExec(5096, arrow_xid8cmp());
+RegisterExec(6170, arrow_pg_stat_reset_replication_slot());
+RegisterExec(6173, arrow_pg_get_statisticsobjdef_expressions());
+RegisterExec(6174, arrow_pg_get_statisticsobjdef_columns());
+RegisterExec(6185, arrow_pg_stat_get_db_session_time());
+RegisterExec(6186, arrow_pg_stat_get_db_active_time());
+RegisterExec(6187, arrow_pg_stat_get_db_idle_in_transaction_time());
+RegisterExec(6188, arrow_pg_stat_get_db_sessions());
+RegisterExec(6189, arrow_pg_stat_get_db_sessions_abandoned());
+RegisterExec(6190, arrow_pg_stat_get_db_sessions_fatal());
+RegisterExec(6191, arrow_pg_stat_get_db_sessions_killed());
+RegisterExec(6192, arrow_hash_record());
+RegisterExec(6193, arrow_hash_record_extended());
+RegisterExec(6197, arrow_pg_get_function_sqlbody());
diff --git a/ydb/library/yql/parser/pg_wrapper/pg_kernels_register.3.inc b/ydb/library/yql/parser/pg_wrapper/pg_kernels_register.3.inc
index 11615afefec..e6a79be540b 100644
--- a/ydb/library/yql/parser/pg_wrapper/pg_kernels_register.3.inc
+++ b/ydb/library/yql/parser/pg_wrapper/pg_kernels_register.3.inc
@@ -1,178 +1,106 @@
-RegisterExec(31, arrow_byteaout());
-RegisterExec(33, arrow_charout());
 RegisterExec(44, arrow_regprocin());
 RegisterExec(45, arrow_regprocout());
-RegisterExec(46, arrow_textin());
-RegisterExec(47, arrow_textout());
-RegisterExec(54, arrow_oidvectorin());
-RegisterExec(55, arrow_oidvectorout());
-RegisterExec(61, arrow_chareq());
-RegisterExec(67, arrow_texteq());
-RegisterExec(70, arrow_charne());
-RegisterExec(72, arrow_charle());
-RegisterExec(73, arrow_chargt());
-RegisterExec(74, arrow_charge());
-RegisterExec(77, arrow_chartoi4());
-RegisterExec(78, arrow_i4tochar());
-RegisterExec(79, arrow_nameregexeq());
-RegisterExec(109, arrow_unknownin());
-RegisterExec(110, arrow_unknownout());
-RegisterExec(157, arrow_textne());
-RegisterExec(184, arrow_oideq());
-RegisterExec(185, arrow_oidne());
-RegisterExec(200, arrow_float4in());
-RegisterExec(201, arrow_float4out());
-RegisterExec(202, arrow_float4mul());
-RegisterExec(203, arrow_float4div());
-RegisterExec(204, arrow_float4pl());
-RegisterExec(205, arrow_float4mi());
-RegisterExec(206, arrow_float4um());
-RegisterExec(207, arrow_float4abs());
-RegisterExec(1394, arrow_float4abs());
-RegisterExec(208, arrow_float4_accum());
-RegisterExec(209, arrow_float4larger());
-RegisterExec(211, arrow_float4smaller());
-RegisterExec(214, arrow_float8in());
-RegisterExec(215, arrow_float8out());
-RegisterExec(216, arrow_float8mul());
-RegisterExec(217, arrow_float8div());
-RegisterExec(218, arrow_float8pl());
-RegisterExec(219, arrow_float8mi());
-RegisterExec(220, arrow_float8um());
-RegisterExec(221, arrow_float8abs());
-RegisterExec(1395, arrow_float8abs());
-RegisterExec(222, arrow_float8_accum());
-RegisterExec(223, arrow_float8larger());
-RegisterExec(224, arrow_float8smaller());
-RegisterExec(228, arrow_dround());
-RegisterExec(1342, arrow_dround());
-RegisterExec(229, arrow_dtrunc());
-RegisterExec(1343, arrow_dtrunc());
-RegisterExec(230, arrow_dsqrt());
-RegisterExec(1344, arrow_dsqrt());
-RegisterExec(231, arrow_dcbrt());
-RegisterExec(1345, arrow_dcbrt());
-RegisterExec(232, arrow_dpow());
-RegisterExec(1346, arrow_dpow());
-RegisterExec(1368, arrow_dpow());
-RegisterExec(233, arrow_dexp());
-RegisterExec(1347, arrow_dexp());
-RegisterExec(234, arrow_dlog1());
-RegisterExec(1341, arrow_dlog1());
-RegisterExec(235, arrow_i2tod());
-RegisterExec(236, arrow_i2tof());
-RegisterExec(237, arrow_dtoi2());
-RegisterExec(238, arrow_ftoi2());
-RegisterExec(240, arrow_nameeqtext());
-RegisterExec(241, arrow_namelttext());
-RegisterExec(242, arrow_nameletext());
-RegisterExec(243, arrow_namegetext());
-RegisterExec(244, arrow_namegttext());
-RegisterExec(245, arrow_namenetext());
-RegisterExec(246, arrow_btnametextcmp());
-RegisterExec(247, arrow_texteqname());
-RegisterExec(248, arrow_textltname());
-RegisterExec(249, arrow_textlename());
-RegisterExec(250, arrow_textgename());
-RegisterExec(251, arrow_textgtname());
-RegisterExec(252, arrow_textnename());
-RegisterExec(253, arrow_bttextnamecmp());
-RegisterExec(276, arrow_float8_combine());
-RegisterExec(279, arrow_float48mul());
-RegisterExec(280, arrow_float48div());
-RegisterExec(281, arrow_float48pl());
-RegisterExec(282, arrow_float48mi());
-RegisterExec(283, arrow_float84mul());
-RegisterExec(284, arrow_float84div());
-RegisterExec(285, arrow_float84pl());
-RegisterExec(286, arrow_float84mi());
-RegisterExec(287, arrow_float4eq());
-RegisterExec(288, arrow_float4ne());
-RegisterExec(289, arrow_float4lt());
-RegisterExec(290, arrow_float4le());
-RegisterExec(291, arrow_float4gt());
-RegisterExec(292, arrow_float4ge());
-RegisterExec(293, arrow_float8eq());
-RegisterExec(294, arrow_float8ne());
-RegisterExec(295, arrow_float8lt());
-RegisterExec(296, arrow_float8le());
-RegisterExec(297, arrow_float8gt());
-RegisterExec(298, arrow_float8ge());
-RegisterExec(299, arrow_float48eq());
-RegisterExec(300, arrow_float48ne());
-RegisterExec(301, arrow_float48lt());
-RegisterExec(302, arrow_float48le());
-RegisterExec(303, arrow_float48gt());
-RegisterExec(304, arrow_float48ge());
-RegisterExec(305, arrow_float84eq());
-RegisterExec(306, arrow_float84ne());
-RegisterExec(307, arrow_float84lt());
-RegisterExec(308, arrow_float84le());
-RegisterExec(309, arrow_float84gt());
-RegisterExec(310, arrow_float84ge());
-RegisterExec(311, arrow_ftod());
-RegisterExec(312, arrow_dtof());
-RegisterExec(315, arrow_pg_jit_available());
-RegisterExec(316, arrow_i4tod());
-RegisterExec(317, arrow_dtoi4());
-RegisterExec(318, arrow_i4tof());
-RegisterExec(319, arrow_ftoi4());
-RegisterExec(320, arrow_width_bucket_float8());
-RegisterExec(330, arrow_bthandler());
-RegisterExec(333, arrow_ginhandler());
-RegisterExec(354, arrow_btfloat4cmp());
-RegisterExec(355, arrow_btfloat8cmp());
-RegisterExec(360, arrow_bttextcmp());
-RegisterExec(376, arrow_text_to_array_null());
+RegisterExec(48, arrow_tidin());
+RegisterExec(49, arrow_tidout());
+RegisterExec(115, arrow_box_above_eq());
+RegisterExec(116, arrow_box_below_eq());
+RegisterExec(117, arrow_point_in());
+RegisterExec(118, arrow_point_out());
+RegisterExec(119, arrow_lseg_in());
+RegisterExec(120, arrow_lseg_out());
+RegisterExec(121, arrow_path_in());
+RegisterExec(122, arrow_path_out());
+RegisterExec(123, arrow_box_in());
+RegisterExec(124, arrow_box_out());
+RegisterExec(125, arrow_box_overlap());
+RegisterExec(126, arrow_box_ge());
+RegisterExec(127, arrow_box_gt());
+RegisterExec(128, arrow_box_eq());
+RegisterExec(129, arrow_box_lt());
+RegisterExec(130, arrow_box_le());
+RegisterExec(131, arrow_point_above());
+RegisterExec(132, arrow_point_left());
+RegisterExec(133, arrow_point_right());
+RegisterExec(134, arrow_point_below());
+RegisterExec(135, arrow_point_eq());
+RegisterExec(136, arrow_on_pb());
+RegisterExec(137, arrow_on_ppath());
+RegisterExec(138, arrow_box_center());
+RegisterExec(1534, arrow_box_center());
+RegisterExec(1542, arrow_box_center());
+RegisterExec(139, arrow_areasel());
+RegisterExec(140, arrow_areajoinsel());
+RegisterExec(186, arrow_box_same());
+RegisterExec(187, arrow_box_contain());
+RegisterExec(188, arrow_box_left());
+RegisterExec(189, arrow_box_overleft());
+RegisterExec(190, arrow_box_overright());
+RegisterExec(191, arrow_box_right());
+RegisterExec(192, arrow_box_contained());
+RegisterExec(193, arrow_box_contain_pt());
+RegisterExec(225, arrow_lseg_center());
+RegisterExec(1532, arrow_lseg_center());
+RegisterExec(226, arrow_path_center());
+RegisterExec(1533, arrow_path_center());
+RegisterExec(227, arrow_poly_center());
+RegisterExec(1540, arrow_poly_center());
+RegisterExec(239, arrow_line_distance());
+RegisterExec(274, arrow_timeofday());
+RegisterExec(277, arrow_inter_sl());
+RegisterExec(278, arrow_inter_lb());
+RegisterExec(339, arrow_poly_same());
+RegisterExec(340, arrow_poly_contain());
+RegisterExec(341, arrow_poly_left());
+RegisterExec(342, arrow_poly_overleft());
+RegisterExec(343, arrow_poly_overright());
+RegisterExec(344, arrow_poly_right());
+RegisterExec(345, arrow_poly_contained());
+RegisterExec(346, arrow_poly_overlap());
+RegisterExec(347, arrow_poly_in());
+RegisterExec(348, arrow_poly_out());
+RegisterExec(357, arrow_dist_bp());
+RegisterExec(361, arrow_lseg_distance());
+RegisterExec(362, arrow_lseg_interpt());
+RegisterExec(363, arrow_dist_ps());
+RegisterExec(364, arrow_dist_pb());
+RegisterExec(365, arrow_dist_sb());
+RegisterExec(366, arrow_close_ps());
+RegisterExec(367, arrow_close_pb());
+RegisterExec(368, arrow_close_sb());
+RegisterExec(369, arrow_on_ps());
+RegisterExec(370, arrow_path_distance());
+RegisterExec(371, arrow_dist_ppath());
+RegisterExec(372, arrow_on_sb());
+RegisterExec(373, arrow_inter_sb());
 RegisterExec(377, arrow_cash_cmp());
-RegisterExec(384, arrow_array_to_text_null());
-RegisterExec(394, arrow_text_to_array());
-RegisterExec(395, arrow_array_to_text());
-RegisterExec(406, arrow_name_text());
-RegisterExec(1401, arrow_name_text());
-RegisterExec(407, arrow_text_name());
-RegisterExec(1400, arrow_text_name());
-RegisterExec(458, arrow_text_larger());
-RegisterExec(459, arrow_text_smaller());
-RegisterExec(619, arrow_oidvectorne());
-RegisterExec(636, arrow_pg_indexam_has_property());
-RegisterExec(637, arrow_pg_index_has_property());
-RegisterExec(638, arrow_pg_index_column_has_property());
-RegisterExec(676, arrow_pg_indexam_progress_phasename());
-RegisterExec(677, arrow_oidvectorlt());
-RegisterExec(678, arrow_oidvectorle());
-RegisterExec(679, arrow_oidvectoreq());
-RegisterExec(680, arrow_oidvectorge());
-RegisterExec(681, arrow_oidvectorgt());
-RegisterExec(716, arrow_oidlt());
-RegisterExec(717, arrow_oidle());
-RegisterExec(720, arrow_byteaoctetlen());
-RegisterExec(2010, arrow_byteaoctetlen());
-RegisterExec(721, arrow_byteaGetByte());
-RegisterExec(722, arrow_byteaSetByte());
-RegisterExec(723, arrow_byteaGetBit());
-RegisterExec(724, arrow_byteaSetBit());
-RegisterExec(740, arrow_text_lt());
-RegisterExec(741, arrow_text_le());
-RegisterExec(742, arrow_text_gt());
-RegisterExec(743, arrow_text_ge());
-RegisterExec(749, arrow_byteaoverlay());
-RegisterExec(752, arrow_byteaoverlay_no_len());
+RegisterExec(378, arrow_array_append());
+RegisterExec(379, arrow_array_prepend());
+RegisterExec(380, arrow_dist_sp());
+RegisterExec(381, arrow_dist_bs());
+RegisterExec(383, arrow_array_cat());
+RegisterExec(421, arrow_dist_pathp());
+RegisterExec(432, arrow_hash_numeric());
+RegisterExec(702, arrow_dist_lp());
+RegisterExec(703, arrow_dist_bl());
+RegisterExec(704, arrow_dist_ls());
+RegisterExec(725, arrow_dist_pl());
+RegisterExec(726, arrow_dist_lb());
+RegisterExec(727, arrow_dist_sl());
+RegisterExec(728, arrow_dist_cpoly());
+RegisterExec(729, arrow_poly_distance());
+RegisterExec(780, arrow_hash_numeric_extended());
+RegisterExec(785, arrow_dist_polyc());
+RegisterExec(817, arrow_current_query());
 RegisterExec(846, arrow_cash_mul_flt4());
 RegisterExec(847, arrow_cash_div_flt4());
 RegisterExec(848, arrow_flt4_mul_cash());
-RegisterExec(849, arrow_textpos());
-RegisterExec(868, arrow_textpos());
+RegisterExec(861, arrow_current_database());
 RegisterExec(862, arrow_int4_mul_cash());
 RegisterExec(863, arrow_int2_mul_cash());
 RegisterExec(864, arrow_cash_mul_int4());
 RegisterExec(865, arrow_cash_div_int4());
 RegisterExec(866, arrow_cash_mul_int2());
 RegisterExec(867, arrow_cash_div_int2());
-RegisterExec(877, arrow_text_substr());
-RegisterExec(936, arrow_text_substr());
-RegisterExec(883, arrow_text_substr_no_len());
-RegisterExec(937, arrow_text_substr_no_len());
 RegisterExec(886, arrow_cash_in());
 RegisterExec(887, arrow_cash_out());
 RegisterExec(888, arrow_cash_eq());
@@ -189,100 +117,364 @@ RegisterExec(898, arrow_cashlarger());
 RegisterExec(899, arrow_cashsmaller());
 RegisterExec(919, arrow_flt8_mul_cash());
 RegisterExec(935, arrow_cash_words());
-RegisterExec(944, arrow_text_char());
-RegisterExec(946, arrow_char_text());
+RegisterExec(959, arrow_on_pl());
+RegisterExec(960, arrow_on_sl());
+RegisterExec(961, arrow_close_pl());
+RegisterExec(962, arrow_close_sl());
+RegisterExec(963, arrow_close_lb());
+RegisterExec(973, arrow_path_inter());
+RegisterExec(975, arrow_box_area());
+RegisterExec(976, arrow_box_width());
+RegisterExec(977, arrow_box_height());
+RegisterExec(978, arrow_box_distance());
+RegisterExec(979, arrow_path_area());
+RegisterExec(980, arrow_box_intersect());
+RegisterExec(981, arrow_box_diagonal());
+RegisterExec(1541, arrow_box_diagonal());
+RegisterExec(982, arrow_path_n_lt());
+RegisterExec(983, arrow_path_n_gt());
+RegisterExec(984, arrow_path_n_eq());
+RegisterExec(985, arrow_path_n_le());
+RegisterExec(986, arrow_path_n_ge());
+RegisterExec(987, arrow_path_length());
+RegisterExec(1531, arrow_path_length());
+RegisterExec(988, arrow_point_ne());
+RegisterExec(989, arrow_point_vert());
+RegisterExec(1406, arrow_point_vert());
+RegisterExec(990, arrow_point_horiz());
+RegisterExec(1407, arrow_point_horiz());
+RegisterExec(991, arrow_point_distance());
+RegisterExec(992, arrow_point_slope());
+RegisterExec(993, arrow_lseg_construct());
+RegisterExec(994, arrow_lseg_intersect());
+RegisterExec(995, arrow_lseg_parallel());
+RegisterExec(1408, arrow_lseg_parallel());
+RegisterExec(996, arrow_lseg_perp());
+RegisterExec(1409, arrow_lseg_perp());
+RegisterExec(997, arrow_lseg_vertical());
+RegisterExec(1410, arrow_lseg_vertical());
+RegisterExec(998, arrow_lseg_horizontal());
+RegisterExec(1411, arrow_lseg_horizontal());
+RegisterExec(999, arrow_lseg_eq());
+RegisterExec(1023, arrow_textlike_support());
+RegisterExec(1024, arrow_texticregexeq_support());
+RegisterExec(1025, arrow_texticlike_support());
+RegisterExec(1026, arrow_timestamptz_izone());
 RegisterExec(1079, arrow_text_regclass());
-RegisterExec(1081, arrow_format_type());
-RegisterExec(1137, arrow_pg_get_wal_replay_pause_state());
-RegisterExec(1194, arrow_dlog10());
-RegisterExec(1339, arrow_dlog10());
-RegisterExec(1340, arrow_dlog10());
-RegisterExec(1238, arrow_texticregexeq());
-RegisterExec(1656, arrow_texticregexeq());
-RegisterExec(1239, arrow_texticregexne());
-RegisterExec(1657, arrow_texticregexne());
-RegisterExec(1240, arrow_nameicregexeq());
-RegisterExec(1241, arrow_nameicregexne());
-RegisterExec(1244, arrow_byteain());
-RegisterExec(1245, arrow_charin());
-RegisterExec(1246, arrow_charlt());
-RegisterExec(1250, arrow_unique_key_recheck());
-RegisterExec(1252, arrow_nameregexne());
-RegisterExec(1254, arrow_textregexeq());
-RegisterExec(1658, arrow_textregexeq());
-RegisterExec(1256, arrow_textregexne());
-RegisterExec(1659, arrow_textregexne());
-RegisterExec(1257, arrow_textlen());
-RegisterExec(1317, arrow_textlen());
-RegisterExec(1369, arrow_textlen());
-RegisterExec(1381, arrow_textlen());
-RegisterExec(1258, arrow_textcat());
-RegisterExec(1269, arrow_pg_column_size());
-RegisterExec(1349, arrow_oidvectortypes());
-RegisterExec(1374, arrow_textoctetlen());
-RegisterExec(1404, arrow_textoverlay());
-RegisterExec(1405, arrow_textoverlay_no_len());
-RegisterExec(1598, arrow_drandom());
-RegisterExec(1599, arrow_setseed());
-RegisterExec(1600, arrow_dasin());
-RegisterExec(1601, arrow_dacos());
-RegisterExec(1602, arrow_datan());
-RegisterExec(1603, arrow_datan2());
-RegisterExec(1604, arrow_dsin());
-RegisterExec(1605, arrow_dcos());
-RegisterExec(1606, arrow_dtan());
-RegisterExec(1607, arrow_dcot());
-RegisterExec(1608, arrow_degrees());
-RegisterExec(1609, arrow_radians());
-RegisterExec(1610, arrow_dpi());
-RegisterExec(1623, arrow_similar_escape());
-RegisterExec(1638, arrow_oidgt());
-RegisterExec(1639, arrow_oidge());
-RegisterExec(1798, arrow_oidin());
-RegisterExec(1799, arrow_oidout());
-RegisterExec(1830, arrow_float8_avg());
-RegisterExec(1831, arrow_float8_var_samp());
-RegisterExec(1832, arrow_float8_stddev_samp());
-RegisterExec(1913, arrow_float4up());
-RegisterExec(1914, arrow_float8up());
-RegisterExec(1948, arrow_byteaeq());
-RegisterExec(1949, arrow_bytealt());
-RegisterExec(1950, arrow_byteale());
-RegisterExec(1951, arrow_byteagt());
-RegisterExec(1952, arrow_byteage());
-RegisterExec(1953, arrow_byteane());
-RegisterExec(1954, arrow_byteacmp());
-RegisterExec(1965, arrow_oidlarger());
-RegisterExec(1966, arrow_oidsmaller());
-RegisterExec(1986, arrow_similar_to_escape_2());
-RegisterExec(1987, arrow_similar_to_escape_1());
-RegisterExec(2011, arrow_byteacat());
-RegisterExec(2012, arrow_bytea_substr());
-RegisterExec(2085, arrow_bytea_substr());
-RegisterExec(2013, arrow_bytea_substr_no_len());
-RegisterExec(2086, arrow_bytea_substr_no_len());
-RegisterExec(2014, arrow_byteapos());
-RegisterExec(2073, arrow_textregexsubstr());
-RegisterExec(2079, arrow_pg_table_is_visible());
-RegisterExec(2080, arrow_pg_type_is_visible());
-RegisterExec(2081, arrow_pg_function_is_visible());
-RegisterExec(2082, arrow_pg_operator_is_visible());
-RegisterExec(2083, arrow_pg_opclass_is_visible());
-RegisterExec(2087, arrow_replace_text());
-RegisterExec(2088, arrow_split_part());
-RegisterExec(2089, arrow_to_hex32());
-RegisterExec(2090, arrow_to_hex64());
-RegisterExec(2093, arrow_pg_conversion_is_visible());
-RegisterExec(2121, arrow_pg_column_compression());
-RegisterExec(2160, arrow_text_pattern_lt());
-RegisterExec(2161, arrow_text_pattern_le());
-RegisterExec(2163, arrow_text_pattern_ge());
-RegisterExec(2164, arrow_text_pattern_gt());
-RegisterExec(2166, arrow_bttext_pattern_cmp());
-RegisterExec(2172, arrow_pg_start_backup());
-RegisterExec(2173, arrow_pg_stop_backup());
-RegisterExec(2194, arrow_btfloat48cmp());
-RegisterExec(2195, arrow_btfloat84cmp());
+RegisterExec(1146, arrow_circle_add_pt());
+RegisterExec(1147, arrow_circle_sub_pt());
+RegisterExec(1148, arrow_circle_mul_pt());
+RegisterExec(1149, arrow_circle_div_pt());
+RegisterExec(1150, arrow_timestamptz_in());
+RegisterExec(1151, arrow_timestamptz_out());
+RegisterExec(1152, arrow_timestamp_eq());
+RegisterExec(2052, arrow_timestamp_eq());
+RegisterExec(1153, arrow_timestamp_ne());
+RegisterExec(2053, arrow_timestamp_ne());
+RegisterExec(1154, arrow_timestamp_lt());
+RegisterExec(2054, arrow_timestamp_lt());
+RegisterExec(1155, arrow_timestamp_le());
+RegisterExec(2055, arrow_timestamp_le());
+RegisterExec(1156, arrow_timestamp_ge());
+RegisterExec(2056, arrow_timestamp_ge());
+RegisterExec(1157, arrow_timestamp_gt());
+RegisterExec(2057, arrow_timestamp_gt());
+RegisterExec(1158, arrow_float8_timestamptz());
+RegisterExec(1159, arrow_timestamptz_zone());
+RegisterExec(1160, arrow_interval_in());
+RegisterExec(1161, arrow_interval_out());
+RegisterExec(1162, arrow_interval_eq());
+RegisterExec(1163, arrow_interval_ne());
+RegisterExec(1164, arrow_interval_lt());
+RegisterExec(1165, arrow_interval_le());
+RegisterExec(1166, arrow_interval_ge());
+RegisterExec(1167, arrow_interval_gt());
+RegisterExec(1168, arrow_interval_um());
+RegisterExec(1169, arrow_interval_pl());
+RegisterExec(1170, arrow_interval_mi());
+RegisterExec(1171, arrow_timestamptz_part());
+RegisterExec(1172, arrow_interval_part());
+RegisterExec(1175, arrow_interval_justify_hours());
+RegisterExec(1188, arrow_timestamp_mi());
+RegisterExec(2031, arrow_timestamp_mi());
+RegisterExec(1189, arrow_timestamptz_pl_interval());
+RegisterExec(1190, arrow_timestamptz_mi_interval());
+RegisterExec(1195, arrow_timestamp_smaller());
+RegisterExec(2035, arrow_timestamp_smaller());
+RegisterExec(1196, arrow_timestamp_larger());
+RegisterExec(2036, arrow_timestamp_larger());
+RegisterExec(1197, arrow_interval_smaller());
+RegisterExec(1198, arrow_interval_larger());
+RegisterExec(1199, arrow_timestamptz_age());
+RegisterExec(1200, arrow_interval_scale());
+RegisterExec(1217, arrow_timestamptz_trunc());
+RegisterExec(1218, arrow_interval_trunc());
+RegisterExec(1265, arrow_tidne());
+RegisterExec(1268, arrow_parse_ident());
+RegisterExec(1282, arrow_quote_ident());
+RegisterExec(1283, arrow_quote_literal());
+RegisterExec(1284, arrow_timestamptz_trunc_zone());
+RegisterExec(1289, arrow_quote_nullable());
+RegisterExec(1292, arrow_tideq());
+RegisterExec(1294, arrow_currtid_byrelname());
+RegisterExec(1295, arrow_interval_justify_days());
+RegisterExec(1299, arrow_now());
+RegisterExec(2647, arrow_now());
+RegisterExec(1300, arrow_positionsel());
+RegisterExec(1301, arrow_positionjoinsel());
+RegisterExec(1302, arrow_contsel());
+RegisterExec(1303, arrow_contjoinsel());
+RegisterExec(1304, arrow_overlaps_timestamp());
+RegisterExec(2041, arrow_overlaps_timestamp());
+RegisterExec(1312, arrow_timestamp_in());
+RegisterExec(1313, arrow_timestamp_out());
+RegisterExec(1314, arrow_timestamp_cmp());
+RegisterExec(2045, arrow_timestamp_cmp());
+RegisterExec(1315, arrow_interval_cmp());
+RegisterExec(1326, arrow_interval_div());
+RegisterExec(1364, arrow_textregexeq_support());
+RegisterExec(1376, arrow_numeric_fac());
+RegisterExec(1389, arrow_timestamp_finite());
+RegisterExec(2048, arrow_timestamp_finite());
+RegisterExec(1390, arrow_interval_finite());
+RegisterExec(1412, arrow_line_parallel());
+RegisterExec(1496, arrow_line_parallel());
+RegisterExec(1413, arrow_line_perp());
+RegisterExec(1497, arrow_line_perp());
+RegisterExec(1414, arrow_line_vertical());
+RegisterExec(1498, arrow_line_vertical());
+RegisterExec(1415, arrow_line_horizontal());
+RegisterExec(1499, arrow_line_horizontal());
+RegisterExec(1416, arrow_circle_center());
+RegisterExec(1472, arrow_circle_center());
+RegisterExec(1543, arrow_circle_center());
+RegisterExec(1421, arrow_points_box());
+RegisterExec(1422, arrow_box_add());
+RegisterExec(1423, arrow_box_sub());
+RegisterExec(1424, arrow_box_mul());
+RegisterExec(1425, arrow_box_div());
+RegisterExec(1428, arrow_poly_contain_pt());
+RegisterExec(1429, arrow_pt_contained_poly());
+RegisterExec(1430, arrow_path_isclosed());
+RegisterExec(1431, arrow_path_isopen());
+RegisterExec(1432, arrow_path_npoints());
+RegisterExec(1545, arrow_path_npoints());
+RegisterExec(1433, arrow_path_close());
+RegisterExec(1434, arrow_path_open());
+RegisterExec(1435, arrow_path_add());
+RegisterExec(1436, arrow_path_add_pt());
+RegisterExec(1437, arrow_path_sub_pt());
+RegisterExec(1438, arrow_path_mul_pt());
+RegisterExec(1439, arrow_path_div_pt());
+RegisterExec(1440, arrow_construct_point());
+RegisterExec(1441, arrow_point_add());
+RegisterExec(1442, arrow_point_sub());
+RegisterExec(1443, arrow_point_mul());
+RegisterExec(1444, arrow_point_div());
+RegisterExec(1445, arrow_poly_npoints());
+RegisterExec(1556, arrow_poly_npoints());
+RegisterExec(1446, arrow_poly_box());
+RegisterExec(1447, arrow_poly_path());
+RegisterExec(1448, arrow_box_poly());
+RegisterExec(1449, arrow_path_poly());
+RegisterExec(1450, arrow_circle_in());
+RegisterExec(1451, arrow_circle_out());
+RegisterExec(1452, arrow_circle_same());
+RegisterExec(1453, arrow_circle_contain());
+RegisterExec(1454, arrow_circle_left());
+RegisterExec(1455, arrow_circle_overleft());
+RegisterExec(1456, arrow_circle_overright());
+RegisterExec(1457, arrow_circle_right());
+RegisterExec(1458, arrow_circle_contained());
+RegisterExec(1459, arrow_circle_overlap());
+RegisterExec(1460, arrow_circle_below());
+RegisterExec(1461, arrow_circle_above());
+RegisterExec(1462, arrow_circle_eq());
+RegisterExec(1463, arrow_circle_ne());
+RegisterExec(1464, arrow_circle_lt());
+RegisterExec(1465, arrow_circle_gt());
+RegisterExec(1466, arrow_circle_le());
+RegisterExec(1467, arrow_circle_ge());
+RegisterExec(1468, arrow_circle_area());
+RegisterExec(1469, arrow_circle_diameter());
+RegisterExec(1470, arrow_circle_radius());
+RegisterExec(1471, arrow_circle_distance());
+RegisterExec(1473, arrow_cr_circle());
+RegisterExec(1474, arrow_poly_circle());
+RegisterExec(1475, arrow_circle_poly());
+RegisterExec(1476, arrow_dist_pc());
+RegisterExec(1477, arrow_circle_contain_pt());
+RegisterExec(1478, arrow_pt_contained_circle());
+RegisterExec(1479, arrow_box_circle());
+RegisterExec(1480, arrow_circle_box());
+RegisterExec(1482, arrow_lseg_ne());
+RegisterExec(1483, arrow_lseg_lt());
+RegisterExec(1484, arrow_lseg_le());
+RegisterExec(1485, arrow_lseg_gt());
+RegisterExec(1486, arrow_lseg_ge());
+RegisterExec(1487, arrow_lseg_length());
+RegisterExec(1530, arrow_lseg_length());
+RegisterExec(1488, arrow_close_ls());
+RegisterExec(1489, arrow_close_lseg());
+RegisterExec(1490, arrow_line_in());
+RegisterExec(1491, arrow_line_out());
+RegisterExec(1492, arrow_line_eq());
+RegisterExec(1493, arrow_line_construct_pp());
+RegisterExec(1494, arrow_line_interpt());
+RegisterExec(1495, arrow_line_intersect());
+RegisterExec(1564, arrow_bit_in());
+RegisterExec(1565, arrow_bit_out());
+RegisterExec(1579, arrow_varbit_in());
+RegisterExec(1580, arrow_varbit_out());
+RegisterExec(1581, arrow_biteq());
+RegisterExec(1666, arrow_biteq());
+RegisterExec(1582, arrow_bitne());
+RegisterExec(1667, arrow_bitne());
+RegisterExec(1592, arrow_bitge());
+RegisterExec(1668, arrow_bitge());
+RegisterExec(1593, arrow_bitgt());
+RegisterExec(1669, arrow_bitgt());
+RegisterExec(1594, arrow_bitle());
+RegisterExec(1670, arrow_bitle());
+RegisterExec(1595, arrow_bitlt());
+RegisterExec(1671, arrow_bitlt());
+RegisterExec(1596, arrow_bitcmp());
+RegisterExec(1672, arrow_bitcmp());
+RegisterExec(1618, arrow_interval_mul());
+RegisterExec(1619, arrow_pg_typeof());
+RegisterExec(1624, arrow_mul_d_interval());
+RegisterExec(1673, arrow_bit_and());
+RegisterExec(1674, arrow_bit_or());
+RegisterExec(1675, arrow_bitxor());
+RegisterExec(1676, arrow_bitnot());
+RegisterExec(1677, arrow_bitshiftleft());
+RegisterExec(1678, arrow_bitshiftright());
+RegisterExec(1679, arrow_bitcat());
+RegisterExec(1680, arrow_bitsubstr());
+RegisterExec(1681, arrow_bitlength());
+RegisterExec(1682, arrow_bitoctetlength());
+RegisterExec(1683, arrow_bitfromint4());
+RegisterExec(1684, arrow_bittoint4());
+RegisterExec(1685, arrow_bit());
+RegisterExec(1687, arrow_varbit());
+RegisterExec(1697, arrow_interval_hash());
+RegisterExec(1698, arrow_bitposition());
+RegisterExec(1699, arrow_bitsubstr_no_len());
+RegisterExec(1701, arrow_numeric_in());
+RegisterExec(1702, arrow_numeric_out());
+RegisterExec(1703, arrow_numeric());
+RegisterExec(1704, arrow_numeric_abs());
+RegisterExec(1705, arrow_numeric_abs());
+RegisterExec(1706, arrow_numeric_sign());
+RegisterExec(1707, arrow_numeric_round());
+RegisterExec(1709, arrow_numeric_trunc());
+RegisterExec(1711, arrow_numeric_ceil());
+RegisterExec(2167, arrow_numeric_ceil());
+RegisterExec(1712, arrow_numeric_floor());
+RegisterExec(1718, arrow_numeric_eq());
+RegisterExec(1719, arrow_numeric_ne());
+RegisterExec(1720, arrow_numeric_gt());
+RegisterExec(1721, arrow_numeric_ge());
+RegisterExec(1722, arrow_numeric_lt());
+RegisterExec(1723, arrow_numeric_le());
+RegisterExec(1724, arrow_numeric_add());
+RegisterExec(1725, arrow_numeric_sub());
+RegisterExec(1726, arrow_numeric_mul());
+RegisterExec(1727, arrow_numeric_div());
+RegisterExec(1728, arrow_numeric_mod());
+RegisterExec(1729, arrow_numeric_mod());
+RegisterExec(1730, arrow_numeric_sqrt());
+RegisterExec(1731, arrow_numeric_sqrt());
+RegisterExec(1732, arrow_numeric_exp());
+RegisterExec(1733, arrow_numeric_exp());
+RegisterExec(1734, arrow_numeric_ln());
+RegisterExec(1735, arrow_numeric_ln());
+RegisterExec(1736, arrow_numeric_log());
+RegisterExec(1737, arrow_numeric_log());
+RegisterExec(1738, arrow_numeric_power());
+RegisterExec(1739, arrow_numeric_power());
+RegisterExec(2169, arrow_numeric_power());
+RegisterExec(1740, arrow_int4_numeric());
+RegisterExec(1742, arrow_float4_numeric());
+RegisterExec(1743, arrow_float8_numeric());
+RegisterExec(1744, arrow_numeric_int4());
+RegisterExec(1745, arrow_numeric_float4());
+RegisterExec(1746, arrow_numeric_float8());
+RegisterExec(1764, arrow_numeric_inc());
+RegisterExec(1766, arrow_numeric_smaller());
+RegisterExec(1767, arrow_numeric_larger());
+RegisterExec(1768, arrow_interval_to_char());
+RegisterExec(1769, arrow_numeric_cmp());
+RegisterExec(1770, arrow_timestamptz_to_char());
+RegisterExec(1771, arrow_numeric_uminus());
+RegisterExec(1772, arrow_numeric_to_char());
+RegisterExec(1773, arrow_int4_to_char());
+RegisterExec(1774, arrow_int8_to_char());
+RegisterExec(1775, arrow_float4_to_char());
+RegisterExec(1776, arrow_float8_to_char());
+RegisterExec(1777, arrow_numeric_to_number());
+RegisterExec(1778, arrow_to_timestamp());
+RegisterExec(1779, arrow_numeric_int8());
+RegisterExec(1780, arrow_to_date());
+RegisterExec(1781, arrow_int8_numeric());
+RegisterExec(1782, arrow_int2_numeric());
+RegisterExec(1783, arrow_numeric_int2());
+RegisterExec(1814, arrow_iclikesel());
+RegisterExec(1815, arrow_icnlikesel());
+RegisterExec(1816, arrow_iclikejoinsel());
+RegisterExec(1817, arrow_icnlikejoinsel());
+RegisterExec(1818, arrow_regexeqsel());
+RegisterExec(1819, arrow_likesel());
+RegisterExec(1820, arrow_icregexeqsel());
+RegisterExec(1821, arrow_regexnesel());
+RegisterExec(1822, arrow_nlikesel());
+RegisterExec(1823, arrow_icregexnesel());
+RegisterExec(1824, arrow_regexeqjoinsel());
+RegisterExec(1825, arrow_likejoinsel());
+RegisterExec(1826, arrow_icregexeqjoinsel());
+RegisterExec(1827, arrow_regexnejoinsel());
+RegisterExec(1828, arrow_nlikejoinsel());
+RegisterExec(1829, arrow_icregexnejoinsel());
+RegisterExec(1833, arrow_numeric_accum());
+RegisterExec(1834, arrow_int2_accum());
+RegisterExec(1835, arrow_int4_accum());
+RegisterExec(1836, arrow_int8_accum());
+RegisterExec(1837, arrow_numeric_avg());
+RegisterExec(1838, arrow_numeric_var_samp());
+RegisterExec(1839, arrow_numeric_stddev_samp());
+RegisterExec(1840, arrow_int2_sum());
+RegisterExec(1841, arrow_int4_sum());
+RegisterExec(1842, arrow_int8_sum());
+RegisterExec(1843, arrow_interval_accum());
+RegisterExec(1844, arrow_interval_avg());
+RegisterExec(1845, arrow_to_ascii_default());
+RegisterExec(1846, arrow_to_ascii_enc());
+RegisterExec(1847, arrow_to_ascii_encname());
+RegisterExec(1915, arrow_numeric_uplus());
+RegisterExec(1946, arrow_binary_encode());
+RegisterExec(1947, arrow_binary_decode());
+RegisterExec(1961, arrow_timestamp_scale());
+RegisterExec(1962, arrow_int2_avg_accum());
+RegisterExec(1963, arrow_int4_avg_accum());
+RegisterExec(1964, arrow_int8_avg());
+RegisterExec(1967, arrow_timestamptz_scale());
+RegisterExec(1973, arrow_numeric_div_trunc());
+RegisterExec(1980, arrow_numeric_div_trunc());
+RegisterExec(2020, arrow_timestamp_trunc());
+RegisterExec(2021, arrow_timestamp_part());
+RegisterExec(2027, arrow_timestamptz_timestamp());
+RegisterExec(2028, arrow_timestamp_timestamptz());
+RegisterExec(2032, arrow_timestamp_pl_interval());
+RegisterExec(2033, arrow_timestamp_mi_interval());
+RegisterExec(2034, arrow_pg_conf_load_time());
+RegisterExec(2039, arrow_timestamp_hash());
+RegisterExec(2049, arrow_timestamp_to_char());
+RegisterExec(2058, arrow_timestamp_age());
+RegisterExec(2069, arrow_timestamp_zone());
+RegisterExec(2070, arrow_timestamp_izone());
+RegisterExec(2075, arrow_bitfromint8());
+RegisterExec(2076, arrow_bittoint8());
+RegisterExec(2170, arrow_width_bucket_numeric());
 RegisterExec(2212, arrow_regprocedurein());
 RegisterExec(2213, arrow_regprocedureout());
 RegisterExec(2214, arrow_regoperin());
@@ -293,28 +485,17 @@ RegisterExec(2218, arrow_regclassin());
 RegisterExec(2219, arrow_regclassout());
 RegisterExec(2220, arrow_regtypein());
 RegisterExec(2221, arrow_regtypeout());
-RegisterExec(2284, arrow_textregexreplace_noopt());
-RegisterExec(2285, arrow_textregexreplace());
-RegisterExec(2308, arrow_dceil());
-RegisterExec(2320, arrow_dceil());
-RegisterExec(2309, arrow_dfloor());
-RegisterExec(2310, arrow_dsign());
-RegisterExec(2412, arrow_bytearecv());
-RegisterExec(2413, arrow_byteasend());
-RegisterExec(2414, arrow_textrecv());
-RegisterExec(2415, arrow_textsend());
-RegisterExec(2416, arrow_unknownrecv());
-RegisterExec(2417, arrow_unknownsend());
-RegisterExec(2418, arrow_oidrecv());
-RegisterExec(2419, arrow_oidsend());
-RegisterExec(2420, arrow_oidvectorrecv());
-RegisterExec(2421, arrow_oidvectorsend());
-RegisterExec(2424, arrow_float4recv());
-RegisterExec(2425, arrow_float4send());
-RegisterExec(2426, arrow_float8recv());
-RegisterExec(2427, arrow_float8send());
-RegisterExec(2434, arrow_charrecv());
-RegisterExec(2435, arrow_charsend());
+RegisterExec(2233, arrow_hashtid());
+RegisterExec(2234, arrow_hashtidextended());
+RegisterExec(2311, arrow_md5_text());
+RegisterExec(2316, arrow_postgresql_fdw_validator());
+RegisterExec(2321, arrow_md5_bytea());
+RegisterExec(2333, arrow_array_agg_transfn());
+RegisterExec(2334, arrow_array_agg_finalfn());
+RegisterExec(2428, arrow_point_recv());
+RegisterExec(2429, arrow_point_send());
+RegisterExec(2438, arrow_tidrecv());
+RegisterExec(2439, arrow_tidsend());
 RegisterExec(2444, arrow_regprocrecv());
 RegisterExec(2445, arrow_regprocsend());
 RegisterExec(2446, arrow_regprocedurerecv());
@@ -327,345 +508,263 @@ RegisterExec(2452, arrow_regclassrecv());
 RegisterExec(2453, arrow_regclasssend());
 RegisterExec(2454, arrow_regtyperecv());
 RegisterExec(2455, arrow_regtypesend());
-RegisterExec(2462, arrow_dsinh());
-RegisterExec(2463, arrow_dcosh());
-RegisterExec(2464, arrow_dtanh());
-RegisterExec(2465, arrow_dasinh());
-RegisterExec(2466, arrow_dacosh());
-RegisterExec(2467, arrow_datanh());
+RegisterExec(2456, arrow_bit_recv());
+RegisterExec(2457, arrow_bit_send());
+RegisterExec(2458, arrow_varbit_recv());
+RegisterExec(2459, arrow_varbit_send());
+RegisterExec(2460, arrow_numeric_recv());
+RegisterExec(2461, arrow_numeric_send());
+RegisterExec(2474, arrow_timestamp_recv());
+RegisterExec(2475, arrow_timestamp_send());
+RegisterExec(2476, arrow_timestamptz_recv());
+RegisterExec(2477, arrow_timestamptz_send());
+RegisterExec(2478, arrow_interval_recv());
+RegisterExec(2479, arrow_interval_send());
+RegisterExec(2480, arrow_lseg_recv());
+RegisterExec(2481, arrow_lseg_send());
+RegisterExec(2482, arrow_path_recv());
+RegisterExec(2483, arrow_path_send());
+RegisterExec(2484, arrow_box_recv());
+RegisterExec(2485, arrow_box_send());
+RegisterExec(2486, arrow_poly_recv());
+RegisterExec(2487, arrow_poly_send());
+RegisterExec(2488, arrow_line_recv());
+RegisterExec(2489, arrow_line_send());
+RegisterExec(2490, arrow_circle_recv());
+RegisterExec(2491, arrow_circle_send());
 RegisterExec(2492, arrow_cash_recv());
 RegisterExec(2493, arrow_cash_send());
-RegisterExec(2512, arrow_float8_var_pop());
-RegisterExec(2513, arrow_float8_stddev_pop());
-RegisterExec(2561, arrow_pg_blocking_pids());
-RegisterExec(2597, arrow_domain_in());
-RegisterExec(2598, arrow_domain_recv());
-RegisterExec(2614, arrow_xmlexists());
-RegisterExec(2731, arrow_dasind());
-RegisterExec(2732, arrow_dacosd());
-RegisterExec(2733, arrow_datand());
-RegisterExec(2734, arrow_datan2d());
-RegisterExec(2735, arrow_dsind());
-RegisterExec(2736, arrow_dcosd());
-RegisterExec(2737, arrow_dtand());
-RegisterExec(2738, arrow_dcotd());
+RegisterExec(2514, arrow_numeric_var_pop());
+RegisterExec(2520, arrow_timestamp_lt_timestamptz());
+RegisterExec(2521, arrow_timestamp_le_timestamptz());
+RegisterExec(2522, arrow_timestamp_eq_timestamptz());
+RegisterExec(2523, arrow_timestamp_gt_timestamptz());
+RegisterExec(2524, arrow_timestamp_ge_timestamptz());
+RegisterExec(2525, arrow_timestamp_ne_timestamptz());
+RegisterExec(2526, arrow_timestamp_cmp_timestamptz());
+RegisterExec(2527, arrow_timestamptz_lt_timestamp());
+RegisterExec(2528, arrow_timestamptz_le_timestamp());
+RegisterExec(2529, arrow_timestamptz_eq_timestamp());
+RegisterExec(2530, arrow_timestamptz_gt_timestamp());
+RegisterExec(2531, arrow_timestamptz_ge_timestamp());
+RegisterExec(2532, arrow_timestamptz_ne_timestamp());
+RegisterExec(2533, arrow_timestamptz_cmp_timestamp());
+RegisterExec(2560, arrow_pg_postmaster_start_time());
+RegisterExec(2562, arrow_box_below());
+RegisterExec(2563, arrow_box_overbelow());
+RegisterExec(2564, arrow_box_overabove());
+RegisterExec(2565, arrow_box_above());
+RegisterExec(2566, arrow_poly_below());
+RegisterExec(2567, arrow_poly_overbelow());
+RegisterExec(2568, arrow_poly_overabove());
+RegisterExec(2569, arrow_poly_above());
+RegisterExec(2587, arrow_circle_overbelow());
+RegisterExec(2588, arrow_circle_overabove());
+RegisterExec(2596, arrow_numeric_stddev_pop());
+RegisterExec(2623, arrow_pg_stat_file_1arg());
+RegisterExec(2624, arrow_pg_read_file_off_len());
+RegisterExec(2626, arrow_pg_sleep());
+RegisterExec(2648, arrow_statement_timestamp());
+RegisterExec(2649, arrow_clock_timestamp());
+RegisterExec(2711, arrow_interval_justify_interval());
+RegisterExec(2740, arrow_numeric_avg_serialize());
+RegisterExec(2741, arrow_numeric_avg_deserialize());
 RegisterExec(2743, arrow_ginarrayextract());
 RegisterExec(2744, arrow_ginarrayconsistent());
-RegisterExec(2767, arrow_regexp_split_to_array_no_flags());
-RegisterExec(2768, arrow_regexp_split_to_array());
+RegisterExec(2746, arrow_int8_avg_accum());
 RegisterExec(2774, arrow_ginqueryarrayextract());
-RegisterExec(2806, arrow_float8_regr_accum());
-RegisterExec(2807, arrow_float8_regr_sxx());
-RegisterExec(2808, arrow_float8_regr_syy());
-RegisterExec(2809, arrow_float8_regr_sxy());
-RegisterExec(2810, arrow_float8_regr_avgx());
-RegisterExec(2811, arrow_float8_regr_avgy());
-RegisterExec(2812, arrow_float8_regr_r2());
-RegisterExec(2813, arrow_float8_regr_slope());
-RegisterExec(2814, arrow_float8_regr_intercept());
-RegisterExec(2815, arrow_float8_covar_pop());
-RegisterExec(2816, arrow_float8_covar_samp());
-RegisterExec(2817, arrow_float8_corr());
-RegisterExec(2848, arrow_pg_switch_wal());
-RegisterExec(2849, arrow_pg_current_wal_lsn());
-RegisterExec(2850, arrow_pg_walfile_name_offset());
-RegisterExec(2851, arrow_pg_walfile_name());
-RegisterExec(2852, arrow_pg_current_wal_insert_lsn());
-RegisterExec(2854, arrow_pg_my_temp_schema());
-RegisterExec(2855, arrow_pg_is_other_temp_schema());
-RegisterExec(2880, arrow_pg_advisory_lock_int8());
-RegisterExec(2881, arrow_pg_advisory_lock_shared_int8());
-RegisterExec(2882, arrow_pg_try_advisory_lock_int8());
-RegisterExec(2883, arrow_pg_try_advisory_lock_shared_int8());
-RegisterExec(2884, arrow_pg_advisory_unlock_int8());
-RegisterExec(2885, arrow_pg_advisory_unlock_shared_int8());
-RegisterExec(2886, arrow_pg_advisory_lock_int4());
-RegisterExec(2887, arrow_pg_advisory_lock_shared_int4());
-RegisterExec(2888, arrow_pg_try_advisory_lock_int4());
-RegisterExec(2889, arrow_pg_try_advisory_lock_shared_int4());
-RegisterExec(2890, arrow_pg_advisory_unlock_int4());
-RegisterExec(2891, arrow_pg_advisory_unlock_shared_int4());
-RegisterExec(2892, arrow_pg_advisory_unlock_all());
-RegisterExec(2893, arrow_xml_in());
-RegisterExec(2894, arrow_xml_out());
-RegisterExec(2895, arrow_xmlcomment());
-RegisterExec(2896, arrow_texttoxml());
-RegisterExec(2897, arrow_xmlvalidate());
-RegisterExec(2898, arrow_xml_recv());
-RegisterExec(2899, arrow_xml_send());
-RegisterExec(2900, arrow_xmlconcat2());
-RegisterExec(2922, arrow_xmltotext());
-RegisterExec(2923, arrow_table_to_xml());
-RegisterExec(2924, arrow_query_to_xml());
-RegisterExec(2925, arrow_cursor_to_xml());
-RegisterExec(2926, arrow_table_to_xmlschema());
-RegisterExec(2927, arrow_query_to_xmlschema());
-RegisterExec(2928, arrow_cursor_to_xmlschema());
-RegisterExec(2929, arrow_table_to_xml_and_xmlschema());
-RegisterExec(2930, arrow_query_to_xml_and_xmlschema());
-RegisterExec(2931, arrow_xpath());
-RegisterExec(2933, arrow_schema_to_xml());
-RegisterExec(2934, arrow_schema_to_xmlschema());
-RegisterExec(2935, arrow_schema_to_xml_and_xmlschema());
-RegisterExec(2936, arrow_database_to_xml());
-RegisterExec(2937, arrow_database_to_xmlschema());
-RegisterExec(2938, arrow_database_to_xml_and_xmlschema());
-RegisterExec(3036, arrow_pg_notify());
-RegisterExec(3049, arrow_xpath_exists());
-RegisterExec(3051, arrow_xml_is_well_formed());
-RegisterExec(3052, arrow_xml_is_well_formed_document());
-RegisterExec(3053, arrow_xml_is_well_formed_content());
-RegisterExec(3060, arrow_text_left());
-RegisterExec(3061, arrow_text_right());
-RegisterExec(3062, arrow_text_reverse());
-RegisterExec(3071, arrow_pg_wal_replay_pause());
-RegisterExec(3072, arrow_pg_wal_replay_resume());
-RegisterExec(3073, arrow_pg_is_wal_replay_paused());
+RegisterExec(2785, arrow_int8_avg_combine());
+RegisterExec(2786, arrow_int8_avg_serialize());
+RegisterExec(2787, arrow_int8_avg_deserialize());
+RegisterExec(2790, arrow_tidgt());
+RegisterExec(2791, arrow_tidlt());
+RegisterExec(2792, arrow_tidge());
+RegisterExec(2793, arrow_tidle());
+RegisterExec(2794, arrow_bttidcmp());
+RegisterExec(2795, arrow_tidlarger());
+RegisterExec(2796, arrow_tidsmaller());
+RegisterExec(2858, arrow_numeric_avg_accum());
+RegisterExec(2902, arrow_varbittypmodin());
+RegisterExec(2903, arrow_intervaltypmodin());
+RegisterExec(2904, arrow_intervaltypmodout());
+RegisterExec(2905, arrow_timestamptypmodin());
+RegisterExec(2906, arrow_timestamptypmodout());
+RegisterExec(2907, arrow_timestamptztypmodin());
+RegisterExec(2908, arrow_timestamptztypmodout());
+RegisterExec(2917, arrow_numerictypmodin());
+RegisterExec(2918, arrow_numerictypmodout());
+RegisterExec(2919, arrow_bittypmodin());
+RegisterExec(2920, arrow_bittypmodout());
+RegisterExec(2921, arrow_varbittypmodout());
+RegisterExec(2939, arrow_pg_snapshot_in());
+RegisterExec(5055, arrow_pg_snapshot_in());
+RegisterExec(2940, arrow_pg_snapshot_out());
+RegisterExec(5056, arrow_pg_snapshot_out());
+RegisterExec(2941, arrow_pg_snapshot_recv());
+RegisterExec(5057, arrow_pg_snapshot_recv());
+RegisterExec(2942, arrow_pg_snapshot_send());
+RegisterExec(5058, arrow_pg_snapshot_send());
+RegisterExec(2943, arrow_pg_current_xact_id());
+RegisterExec(5059, arrow_pg_current_xact_id());
+RegisterExec(2944, arrow_pg_current_snapshot());
+RegisterExec(5061, arrow_pg_current_snapshot());
+RegisterExec(2945, arrow_pg_snapshot_xmin());
+RegisterExec(5062, arrow_pg_snapshot_xmin());
+RegisterExec(2946, arrow_pg_snapshot_xmax());
+RegisterExec(5063, arrow_pg_snapshot_xmax());
+RegisterExec(2948, arrow_pg_visible_in_snapshot());
+RegisterExec(5065, arrow_pg_visible_in_snapshot());
+RegisterExec(3030, arrow_bitoverlay());
+RegisterExec(3031, arrow_bitoverlay_no_len());
+RegisterExec(3032, arrow_bitgetbit());
+RegisterExec(3033, arrow_bitsetbit());
 RegisterExec(3076, arrow_ginarrayextract_2args());
-RegisterExec(3089, arrow_pg_advisory_xact_lock_int8());
-RegisterExec(3090, arrow_pg_advisory_xact_lock_shared_int8());
-RegisterExec(3091, arrow_pg_try_advisory_xact_lock_int8());
-RegisterExec(3092, arrow_pg_try_advisory_xact_lock_shared_int8());
-RegisterExec(3093, arrow_pg_advisory_xact_lock_int4());
-RegisterExec(3094, arrow_pg_advisory_xact_lock_shared_int4());
-RegisterExec(3095, arrow_pg_try_advisory_xact_lock_int4());
-RegisterExec(3096, arrow_pg_try_advisory_xact_lock_shared_int4());
-RegisterExec(3098, arrow_pg_create_restore_point());
-RegisterExec(3132, arrow_btfloat4sortsupport());
-RegisterExec(3133, arrow_btfloat8sortsupport());
-RegisterExec(3165, arrow_pg_wal_lsn_diff());
-RegisterExec(3169, arrow_rangesel());
-RegisterExec(3204, arrow_json_to_record());
-RegisterExec(3207, arrow_jsonb_array_length());
-RegisterExec(3209, arrow_jsonb_populate_record());
-RegisterExec(3214, arrow_jsonb_object_field_text());
-RegisterExec(3215, arrow_jsonb_array_element());
-RegisterExec(3216, arrow_jsonb_array_element_text());
-RegisterExec(3229, arrow_pg_lsn_in());
-RegisterExec(3230, arrow_pg_lsn_out());
-RegisterExec(3231, arrow_pg_lsn_lt());
-RegisterExec(3232, arrow_pg_lsn_le());
-RegisterExec(3233, arrow_pg_lsn_eq());
-RegisterExec(3234, arrow_pg_lsn_ge());
-RegisterExec(3235, arrow_pg_lsn_gt());
-RegisterExec(3236, arrow_pg_lsn_ne());
-RegisterExec(3237, arrow_pg_lsn_mi());
-RegisterExec(3238, arrow_pg_lsn_recv());
-RegisterExec(3239, arrow_pg_lsn_send());
-RegisterExec(3251, arrow_pg_lsn_cmp());
-RegisterExec(3252, arrow_pg_lsn_hash());
-RegisterExec(3255, arrow_bttextsortsupport());
-RegisterExec(3261, arrow_json_strip_nulls());
-RegisterExec(3262, arrow_jsonb_strip_nulls());
-RegisterExec(3296, arrow_pg_notification_queue_usage());
+RegisterExec(3137, arrow_timestamp_sortsupport());
+RegisterExec(3157, arrow_numeric_support());
+RegisterExec(3158, arrow_varbit_support());
+RegisterExec(3162, arrow_pg_collation_for());
+RegisterExec(3178, arrow_numeric_sum());
+RegisterExec(3275, arrow_dist_ppoly());
+RegisterExec(3277, arrow_array_position());
+RegisterExec(3278, arrow_array_position_start());
+RegisterExec(3279, arrow_array_positions());
+RegisterExec(3281, arrow_numeric_scale());
+RegisterExec(3283, arrow_numeric_sortsupport());
+RegisterExec(3290, arrow_dist_cpoint());
+RegisterExec(3292, arrow_dist_polyp());
+RegisterExec(3293, arrow_pg_read_file_v2());
+RegisterExec(3295, arrow_pg_read_binary_file());
 RegisterExec(3298, arrow_row_security_active());
 RegisterExec(3299, arrow_row_security_active_name());
-RegisterExec(3301, arrow_jsonb_concat());
-RegisterExec(3302, arrow_jsonb_delete());
-RegisterExec(3303, arrow_jsonb_delete_idx());
-RegisterExec(3304, arrow_jsonb_delete_path());
-RegisterExec(3305, arrow_jsonb_set());
-RegisterExec(3306, arrow_jsonb_pretty());
+RegisterExec(3307, arrow_pg_stat_file());
 RegisterExec(3313, arrow_tsm_bernoulli_handler());
-RegisterExec(3314, arrow_tsm_system_handler());
-RegisterExec(3330, arrow_pg_current_wal_flush_lsn());
-RegisterExec(3331, arrow_bytea_sortsupport());
-RegisterExec(3332, arrow_bttext_pattern_sortsupport());
-RegisterExec(3342, arrow_float8_regr_combine());
+RegisterExec(3324, arrow_int4_avg_combine());
+RegisterExec(3325, arrow_interval_combine());
+RegisterExec(3335, arrow_numeric_serialize());
+RegisterExec(3336, arrow_numeric_deserialize());
+RegisterExec(3337, arrow_numeric_avg_combine());
+RegisterExec(3338, arrow_numeric_poly_combine());
+RegisterExec(3339, arrow_numeric_poly_serialize());
+RegisterExec(3340, arrow_numeric_poly_deserialize());
+RegisterExec(3341, arrow_numeric_combine());
 RegisterExec(3344, arrow_cash_mul_int8());
 RegisterExec(3345, arrow_cash_div_int8());
-RegisterExec(3376, arrow_pg_safe_snapshot_blocking_pids());
-RegisterExec(3378, arrow_pg_isolation_test_session_is_blocked());
-RegisterExec(3396, arrow_regexp_match_no_flags());
-RegisterExec(3397, arrow_regexp_match());
+RegisterExec(3348, arrow_pg_current_xact_id_if_assigned());
+RegisterExec(5060, arrow_pg_current_xact_id_if_assigned());
+RegisterExec(3360, arrow_pg_xact_status());
+RegisterExec(5066, arrow_pg_xact_status());
+RegisterExec(3382, arrow_pg_identify_object_as_address());
+RegisterExec(3387, arrow_int8_avg_accum_inv());
+RegisterExec(3388, arrow_numeric_poly_sum());
+RegisterExec(3389, arrow_numeric_poly_avg());
+RegisterExec(3390, arrow_numeric_poly_var_pop());
+RegisterExec(3391, arrow_numeric_poly_var_samp());
+RegisterExec(3392, arrow_numeric_poly_stddev_pop());
+RegisterExec(3393, arrow_numeric_poly_stddev_samp());
 RegisterExec(3399, arrow_int8_mul_cash());
-RegisterExec(3403, arrow_pg_statistics_obj_is_visible());
-RegisterExec(3413, arrow_pg_lsn_hash_extended());
-RegisterExec(3416, arrow_jsonb_hash_extended());
+RegisterExec(3411, arrow_timestamp_hash_extended());
+RegisterExec(3418, arrow_interval_hash_extended());
+RegisterExec(3419, arrow_sha224_bytea());
+RegisterExec(3420, arrow_sha256_bytea());
+RegisterExec(3421, arrow_sha384_bytea());
+RegisterExec(3422, arrow_sha512_bytea());
 RegisterExec(3424, arrow_pg_partition_root());
-RegisterExec(3436, arrow_pg_promote());
-RegisterExec(3441, arrow_pg_control_system());
-RegisterExec(3442, arrow_pg_control_checkpoint());
-RegisterExec(3443, arrow_pg_control_recovery());
-RegisterExec(3444, arrow_pg_control_init());
+RegisterExec(3437, arrow_prefixsel());
+RegisterExec(3438, arrow_prefixjoinsel());
+RegisterExec(3461, arrow_make_timestamp());
+RegisterExec(3462, arrow_make_timestamptz());
+RegisterExec(3463, arrow_make_timestamptz_at_timezone());
+RegisterExec(3464, arrow_make_interval());
 RegisterExec(3476, arrow_to_regoperator());
-RegisterExec(3478, arrow_jsonb_object_field());
 RegisterExec(3479, arrow_to_regprocedure());
-RegisterExec(3490, arrow_jsonb_to_record());
 RegisterExec(3492, arrow_to_regoper());
 RegisterExec(3493, arrow_to_regtype());
 RegisterExec(3494, arrow_to_regproc());
 RegisterExec(3495, arrow_to_regclass());
-RegisterExec(3535, arrow_string_agg_transfn());
-RegisterExec(3536, arrow_string_agg_finalfn());
-RegisterExec(3540, arrow_text_format_nv());
-RegisterExec(3543, arrow_bytea_string_agg_transfn());
-RegisterExec(3544, arrow_bytea_string_agg_finalfn());
-RegisterExec(3579, arrow_jsonb_insert());
-RegisterExec(3581, arrow_pg_xact_commit_timestamp());
-RegisterExec(3582, arrow_binary_upgrade_set_next_pg_type_oid());
-RegisterExec(3583, arrow_pg_last_committed_xact());
-RegisterExec(3584, arrow_binary_upgrade_set_next_array_pg_type_oid());
-RegisterExec(3586, arrow_binary_upgrade_set_next_heap_pg_class_oid());
-RegisterExec(3587, arrow_binary_upgrade_set_next_index_pg_class_oid());
-RegisterExec(3588, arrow_binary_upgrade_set_next_toast_pg_class_oid());
-RegisterExec(3589, arrow_binary_upgrade_set_next_pg_enum_oid());
-RegisterExec(3590, arrow_binary_upgrade_set_next_pg_authid_oid());
-RegisterExec(3591, arrow_binary_upgrade_create_empty_extension());
+RegisterExec(3537, arrow_pg_describe_object());
+RegisterExec(3548, arrow_numeric_accum_inv());
+RegisterExec(3549, arrow_interval_accum_inv());
+RegisterExec(3553, arrow_inet_gist_consistent());
+RegisterExec(3554, arrow_inet_gist_union());
+RegisterExec(3555, arrow_inet_gist_compress());
+RegisterExec(3557, arrow_inet_gist_penalty());
+RegisterExec(3558, arrow_inet_gist_picksplit());
+RegisterExec(3559, arrow_inet_gist_same());
+RegisterExec(3567, arrow_int2_accum_inv());
+RegisterExec(3568, arrow_int4_accum_inv());
+RegisterExec(3569, arrow_int8_accum_inv());
+RegisterExec(3570, arrow_int2_avg_accum_inv());
+RegisterExec(3571, arrow_int4_avg_accum_inv());
+RegisterExec(3572, arrow_int2int4_sum());
+RegisterExec(3573, arrow_inet_gist_fetch());
+RegisterExec(3684, arrow_tsquery_rewrite());
+RegisterExec(3685, arrow_tsquery_rewrite_query());
+RegisterExec(3686, arrow_tsmatchsel());
+RegisterExec(3687, arrow_tsmatchjoinsel());
 RegisterExec(3688, arrow_ts_typanalyze());
-RegisterExec(3696, arrow_text_starts_with());
-RegisterExec(3703, arrow_ts_rank_wttf());
-RegisterExec(3704, arrow_ts_rank_wtt());
-RegisterExec(3705, arrow_ts_rank_ttf());
-RegisterExec(3706, arrow_ts_rank_tt());
-RegisterExec(3707, arrow_ts_rankcd_wttf());
-RegisterExec(3708, arrow_ts_rankcd_wtt());
-RegisterExec(3709, arrow_ts_rankcd_ttf());
-RegisterExec(3710, arrow_ts_rankcd_tt());
+RegisterExec(3723, arrow_ts_lexize());
 RegisterExec(3736, arrow_regconfigin());
 RegisterExec(3737, arrow_regconfigout());
 RegisterExec(3738, arrow_regconfigrecv());
 RegisterExec(3739, arrow_regconfigsend());
-RegisterExec(3756, arrow_pg_ts_parser_is_visible());
-RegisterExec(3757, arrow_pg_ts_dict_is_visible());
-RegisterExec(3758, arrow_pg_ts_config_is_visible());
-RegisterExec(3768, arrow_pg_ts_template_is_visible());
+RegisterExec(3740, arrow_thesaurus_init());
+RegisterExec(3741, arrow_thesaurus_lexize());
 RegisterExec(3771, arrow_regdictionaryin());
 RegisterExec(3772, arrow_regdictionaryout());
 RegisterExec(3773, arrow_regdictionaryrecv());
 RegisterExec(3774, arrow_regdictionarysend());
-RegisterExec(3810, arrow_pg_is_in_recovery());
+RegisterExec(3778, arrow_pg_tablespace_location());
+RegisterExec(3779, arrow_pg_create_physical_replication_slot());
+RegisterExec(3780, arrow_pg_drop_replication_slot());
+RegisterExec(3786, arrow_pg_create_logical_replication_slot());
+RegisterExec(3800, arrow_pg_current_logfile());
+RegisterExec(3801, arrow_pg_current_logfile_1arg());
 RegisterExec(3811, arrow_int4_cash());
 RegisterExec(3812, arrow_int8_cash());
-RegisterExec(3813, arrow_pg_is_in_backup());
-RegisterExec(3814, arrow_pg_backup_start_time());
-RegisterExec(3815, arrow_pg_collation_is_visible());
-RegisterExec(3820, arrow_pg_last_wal_receive_lsn());
-RegisterExec(3821, arrow_pg_last_wal_replay_lsn());
+RegisterExec(3816, arrow_array_typanalyze());
 RegisterExec(3822, arrow_cash_div_cash());
 RegisterExec(3823, arrow_cash_numeric());
 RegisterExec(3824, arrow_numeric_cash());
-RegisterExec(3829, arrow_pg_opfamily_is_visible());
-RegisterExec(3830, arrow_pg_last_xact_replay_timestamp());
+RegisterExec(3826, arrow_pg_read_file_all());
+RegisterExec(3827, arrow_pg_read_binary_file_off_len());
+RegisterExec(3828, arrow_pg_read_binary_file_all());
+RegisterExec(3839, arrow_pg_identify_object());
+RegisterExec(3842, arrow_pg_relation_is_updatable());
+RegisterExec(3843, arrow_pg_column_is_updatable());
+RegisterExec(3878, arrow_pg_replication_slot_advance());
+RegisterExec(3917, arrow_timestamp_support());
+RegisterExec(3918, arrow_interval_support());
 RegisterExec(3920, arrow_ginarraytriconsistent());
-RegisterExec(3947, arrow_json_object_field());
-RegisterExec(3948, arrow_json_object_field_text());
-RegisterExec(3949, arrow_json_array_element());
-RegisterExec(3950, arrow_json_array_element_text());
-RegisterExec(3956, arrow_json_array_length());
-RegisterExec(3960, arrow_json_populate_record());
-RegisterExec(4001, arrow_jsonpath_in());
-RegisterExec(4002, arrow_jsonpath_recv());
-RegisterExec(4003, arrow_jsonpath_out());
-RegisterExec(4004, arrow_jsonpath_send());
-RegisterExec(4038, arrow_jsonb_ne());
-RegisterExec(4039, arrow_jsonb_lt());
-RegisterExec(4040, arrow_jsonb_gt());
-RegisterExec(4041, arrow_jsonb_le());
-RegisterExec(4042, arrow_jsonb_ge());
-RegisterExec(4043, arrow_jsonb_eq());
-RegisterExec(4044, arrow_jsonb_cmp());
-RegisterExec(4045, arrow_jsonb_hash());
-RegisterExec(4046, arrow_jsonb_contains());
-RegisterExec(4047, arrow_jsonb_exists());
-RegisterExec(4048, arrow_jsonb_exists_any());
-RegisterExec(4049, arrow_jsonb_exists_all());
-RegisterExec(4050, arrow_jsonb_contained());
-RegisterExec(4083, arrow_binary_upgrade_set_record_init_privs());
+RegisterExec(3954, arrow_pg_get_object_address());
+RegisterExec(4051, arrow_array_agg_array_transfn());
+RegisterExec(4052, arrow_array_agg_array_finalfn());
+RegisterExec(4067, arrow_boxes_bound_box());
 RegisterExec(4084, arrow_regnamespacein());
 RegisterExec(4085, arrow_regnamespaceout());
 RegisterExec(4086, arrow_to_regnamespace());
 RegisterExec(4087, arrow_regnamespacerecv());
 RegisterExec(4088, arrow_regnamespacesend());
+RegisterExec(4091, arrow_point_box());
 RegisterExec(4092, arrow_regroleout());
 RegisterExec(4093, arrow_to_regrole());
 RegisterExec(4094, arrow_regrolerecv());
 RegisterExec(4095, arrow_regrolesend());
 RegisterExec(4098, arrow_regrolein());
-RegisterExec(4101, arrow_binary_upgrade_set_missing_value());
-RegisterExec(4105, arrow_brin_inclusion_opcinfo());
-RegisterExec(4106, arrow_brin_inclusion_add_value());
-RegisterExec(4107, arrow_brin_inclusion_consistent());
-RegisterExec(4108, arrow_brin_inclusion_union());
-RegisterExec(4139, arrow_in_range_float8_float8());
-RegisterExec(4140, arrow_in_range_float4_float8());
-RegisterExec(4187, arrow_pg_lsn_larger());
-RegisterExec(4188, arrow_pg_lsn_smaller());
+RegisterExec(4100, arrow_pg_read_file());
+RegisterExec(4134, arrow_in_range_timestamp_interval());
+RegisterExec(4135, arrow_in_range_timestamptz_interval());
+RegisterExec(4136, arrow_in_range_interval_interval());
+RegisterExec(4141, arrow_in_range_numeric_numeric());
 RegisterExec(4193, arrow_regcollationin());
 RegisterExec(4194, arrow_regcollationout());
 RegisterExec(4195, arrow_to_regcollation());
 RegisterExec(4196, arrow_regcollationrecv());
 RegisterExec(4197, arrow_regcollationsend());
-RegisterExec(4228, arrow_range_merge_from_multirange());
-RegisterExec(4231, arrow_multirange_in());
-RegisterExec(4232, arrow_multirange_out());
-RegisterExec(4233, arrow_multirange_recv());
-RegisterExec(4234, arrow_multirange_send());
-RegisterExec(4235, arrow_multirange_lower());
-RegisterExec(4236, arrow_multirange_upper());
-RegisterExec(4237, arrow_multirange_empty());
-RegisterExec(4238, arrow_multirange_lower_inc());
-RegisterExec(4239, arrow_multirange_upper_inc());
-RegisterExec(4240, arrow_multirange_lower_inf());
-RegisterExec(4241, arrow_multirange_upper_inf());
-RegisterExec(4244, arrow_multirange_eq());
-RegisterExec(4245, arrow_multirange_ne());
-RegisterExec(4246, arrow_range_overlaps_multirange());
-RegisterExec(4247, arrow_multirange_overlaps_range());
-RegisterExec(4248, arrow_multirange_overlaps_multirange());
-RegisterExec(4249, arrow_multirange_contains_elem());
-RegisterExec(4250, arrow_multirange_contains_range());
-RegisterExec(4251, arrow_multirange_contains_multirange());
-RegisterExec(4252, arrow_elem_contained_by_multirange());
-RegisterExec(4253, arrow_range_contained_by_multirange());
-RegisterExec(4254, arrow_multirange_contained_by_multirange());
-RegisterExec(4255, arrow_range_adjacent_multirange());
-RegisterExec(4256, arrow_multirange_adjacent_multirange());
-RegisterExec(4257, arrow_multirange_adjacent_range());
-RegisterExec(4258, arrow_range_before_multirange());
-RegisterExec(4259, arrow_multirange_before_range());
-RegisterExec(4260, arrow_multirange_before_multirange());
-RegisterExec(4261, arrow_range_after_multirange());
-RegisterExec(4262, arrow_multirange_after_range());
-RegisterExec(4263, arrow_multirange_after_multirange());
-RegisterExec(4264, arrow_range_overleft_multirange());
-RegisterExec(4265, arrow_multirange_overleft_range());
-RegisterExec(4266, arrow_multirange_overleft_multirange());
-RegisterExec(4267, arrow_range_overright_multirange());
-RegisterExec(4268, arrow_multirange_overright_range());
-RegisterExec(4269, arrow_multirange_overright_multirange());
-RegisterExec(4270, arrow_multirange_union());
-RegisterExec(4271, arrow_multirange_minus());
-RegisterExec(4272, arrow_multirange_intersect());
-RegisterExec(4273, arrow_multirange_cmp());
-RegisterExec(4274, arrow_multirange_lt());
-RegisterExec(4275, arrow_multirange_le());
-RegisterExec(4276, arrow_multirange_ge());
-RegisterExec(4277, arrow_multirange_gt());
-RegisterExec(4278, arrow_hash_multirange());
-RegisterExec(4279, arrow_hash_multirange_extended());
-RegisterExec(4280, arrow_multirange_constructor0());
-RegisterExec(4283, arrow_multirange_constructor0());
-RegisterExec(4286, arrow_multirange_constructor0());
-RegisterExec(4289, arrow_multirange_constructor0());
-RegisterExec(4292, arrow_multirange_constructor0());
-RegisterExec(4295, arrow_multirange_constructor0());
-RegisterExec(4281, arrow_multirange_constructor1());
-RegisterExec(4284, arrow_multirange_constructor1());
-RegisterExec(4287, arrow_multirange_constructor1());
-RegisterExec(4290, arrow_multirange_constructor1());
-RegisterExec(4293, arrow_multirange_constructor1());
-RegisterExec(4296, arrow_multirange_constructor1());
-RegisterExec(4298, arrow_multirange_constructor1());
-RegisterExec(4299, arrow_range_agg_transfn());
-RegisterExec(4300, arrow_range_agg_finalfn());
-RegisterExec(4350, arrow_unicode_normalize_func());
-RegisterExec(4351, arrow_unicode_is_normalized());
-RegisterExec(4388, arrow_multirange_intersect_agg_transfn());
-RegisterExec(4390, arrow_binary_upgrade_set_next_multirange_pg_type_oid());
-RegisterExec(4391, arrow_binary_upgrade_set_next_multirange_array_pg_type_oid());
-RegisterExec(4541, arrow_range_contains_multirange());
-RegisterExec(4542, arrow_multirange_contained_by_range());
+RegisterExec(4220, arrow_pg_copy_physical_replication_slot_a());
+RegisterExec(4221, arrow_pg_copy_physical_replication_slot_b());
+RegisterExec(4222, arrow_pg_copy_logical_replication_slot_a());
+RegisterExec(4223, arrow_pg_copy_logical_replication_slot_b());
+RegisterExec(4224, arrow_pg_copy_logical_replication_slot_c());
 RegisterExec(4591, arrow_brin_bloom_opcinfo());
 RegisterExec(4592, arrow_brin_bloom_add_value());
 RegisterExec(4593, arrow_brin_bloom_consistent());
@@ -675,40 +774,22 @@ RegisterExec(4596, arrow_brin_bloom_summary_in());
 RegisterExec(4597, arrow_brin_bloom_summary_out());
 RegisterExec(4598, arrow_brin_bloom_summary_recv());
 RegisterExec(4599, arrow_brin_bloom_summary_send());
-RegisterExec(4616, arrow_brin_minmax_multi_opcinfo());
-RegisterExec(4617, arrow_brin_minmax_multi_add_value());
-RegisterExec(4618, arrow_brin_minmax_multi_consistent());
-RegisterExec(4619, arrow_brin_minmax_multi_union());
-RegisterExec(4620, arrow_brin_minmax_multi_options());
-RegisterExec(4621, arrow_brin_minmax_multi_distance_int2());
-RegisterExec(4622, arrow_brin_minmax_multi_distance_int4());
-RegisterExec(4623, arrow_brin_minmax_multi_distance_int8());
-RegisterExec(4624, arrow_brin_minmax_multi_distance_float4());
-RegisterExec(4625, arrow_brin_minmax_multi_distance_float8());
-RegisterExec(4626, arrow_brin_minmax_multi_distance_numeric());
-RegisterExec(4627, arrow_brin_minmax_multi_distance_tid());
-RegisterExec(4628, arrow_brin_minmax_multi_distance_uuid());
-RegisterExec(4629, arrow_brin_minmax_multi_distance_date());
-RegisterExec(4630, arrow_brin_minmax_multi_distance_time());
-RegisterExec(4631, arrow_brin_minmax_multi_distance_interval());
-RegisterExec(4632, arrow_brin_minmax_multi_distance_timetz());
-RegisterExec(4633, arrow_brin_minmax_multi_distance_pg_lsn());
-RegisterExec(4634, arrow_brin_minmax_multi_distance_macaddr());
-RegisterExec(4635, arrow_brin_minmax_multi_distance_macaddr8());
-RegisterExec(4636, arrow_brin_minmax_multi_distance_inet());
-RegisterExec(4637, arrow_brin_minmax_multi_distance_timestamp());
-RegisterExec(4638, arrow_brin_minmax_multi_summary_in());
-RegisterExec(4639, arrow_brin_minmax_multi_summary_out());
-RegisterExec(4640, arrow_brin_minmax_multi_summary_recv());
-RegisterExec(4641, arrow_brin_minmax_multi_summary_send());
-RegisterExec(5022, arrow_pg_lsn_pli());
-RegisterExec(5024, arrow_pg_lsn_mii());
-RegisterExec(5050, arrow_btvarstrequalimage());
-RegisterExec(5051, arrow_btequalimage());
-RegisterExec(5054, arrow_jsonb_set_lax());
-RegisterExec(6121, arrow_pg_relation_is_publishable());
-RegisterExec(6163, arrow_bytea_bit_count());
-RegisterExec(6168, arrow_pg_xact_commit_timestamp_origin());
-RegisterExec(6179, arrow_array_subscript_handler());
-RegisterExec(6180, arrow_raw_array_subscript_handler());
-RegisterExec(6198, arrow_unistr());
+RegisterExec(5010, arrow_spg_bbox_quad_config());
+RegisterExec(5011, arrow_spg_poly_quad_compress());
+RegisterExec(5012, arrow_spg_box_quad_config());
+RegisterExec(5013, arrow_spg_box_quad_choose());
+RegisterExec(5014, arrow_spg_box_quad_picksplit());
+RegisterExec(5015, arrow_spg_box_quad_inner_consistent());
+RegisterExec(5016, arrow_spg_box_quad_leaf_consistent());
+RegisterExec(5042, arrow_numeric_min_scale());
+RegisterExec(5043, arrow_numeric_trim_scale());
+RegisterExec(5048, arrow_numeric_gcd());
+RegisterExec(5049, arrow_numeric_lcm());
+RegisterExec(6103, arrow_numeric_pg_lsn());
+RegisterExec(6120, arrow_pg_get_replica_identity_index());
+RegisterExec(6162, arrow_bit_bit_count());
+RegisterExec(6177, arrow_timestamp_bin());
+RegisterExec(6178, arrow_timestamptz_bin());
+RegisterExec(6202, arrow_extract_timestamp());
+RegisterExec(6203, arrow_extract_timestamptz());
+RegisterExec(6204, arrow_extract_interval());
diff --git a/ydb/library/yql/parser/pg_wrapper/ut/codegen_ut.cpp b/ydb/library/yql/parser/pg_wrapper/ut/codegen_ut.cpp
index 18d18a07528..38f43fee5a7 100644
--- a/ydb/library/yql/parser/pg_wrapper/ut/codegen_ut.cpp
+++ b/ydb/library/yql/parser/pg_wrapper/ut/codegen_ut.cpp
@@ -29,6 +29,7 @@ extern "C" {
 }
 
 enum class EKernelFlavor {
+    Indirect,
     DefArg,
     Cpp,
     BitCode,
@@ -38,14 +39,22 @@ enum class EKernelFlavor {
 Y_UNIT_TEST_SUITE(TPgCodegen) {
     void PgFuncImpl(EKernelFlavor flavor, bool constArg, bool fixed) {
         const TString& name = fixed ? "date_eq" : "textout";
-        TExecFunc execFunc;
         ICodegen::TPtr codegen;
+        TExecFunc execFunc;        
         switch (flavor) {
+        case EKernelFlavor::Indirect: {
+            if (fixed) {
+                execFunc = MakeIndirectExec<true, true>(&date_eq);
+            } else {
+                execFunc = MakeIndirectExec<true, false>(&textout);
+            }
+            break;
+        }
         case EKernelFlavor::DefArg: {
             if (fixed) {
-                execFunc = &GenericExec<TPgDirectFunc<&date_eq>, true, true, TDefaultArgsPolicy>;
+                execFunc = TGenericExec<TPgDirectFunc<&date_eq>, true, true, TDefaultArgsPolicy>({});
             } else {
-                execFunc = &GenericExec<TPgDirectFunc<&textout>, true, false, TDefaultArgsPolicy>;
+                execFunc = TGenericExec<TPgDirectFunc<&textout>, true, false, TDefaultArgsPolicy>({});
             }
             break;
         }
@@ -55,14 +64,15 @@ Y_UNIT_TEST_SUITE(TPgCodegen) {
         }
         case EKernelFlavor::BitCode: {
             codegen = ICodegen::Make(ETarget::Native);
-            auto bitcode = NResource::Find(fixed ? "/llvm_bc/PgFuncs1" : "/llvm_bc/PgFuncs3");
+            auto bitcode = NResource::Find(fixed ? "/llvm_bc/PgFuncs1" : "/llvm_bc/PgFuncs1");
             codegen->LoadBitCode(bitcode, "Funcs");
             auto func = codegen->GetModule().getFunction(std::string("arrow_" + name));
+            Y_ENSURE(func);
             codegen->AddGlobalMapping("GetPGKernelState", (const void*)&GetPGKernelState);
             codegen->Verify();
             codegen->ExportSymbol(func);
             codegen->Compile();
-            //codegen->ShowGeneratedFunctions(&Cerr);        
+            //codegen->ShowGeneratedFunctions(&Cerr);
             typedef TExecFunc (*TFunc)();
             auto funcPtr = (TFunc)codegen->GetPointerToFunction(func);
             execFunc = funcPtr();
@@ -129,6 +139,7 @@ Y_UNIT_TEST_SUITE(TPgCodegen) {
                         }
                     }
 
+                    *res = builder.Build(true);
                     return arrow::Status::OK();
                 };
             };
@@ -164,7 +175,11 @@ Y_UNIT_TEST_SUITE(TPgCodegen) {
             state.IsFixedArg.push_back(false);
         }
 
+#ifdef NDEBUG
         const size_t N = 10000;
+#else
+        const size_t N = 1000;
+#endif
         std::vector<arrow::Datum> batchArgs;
         if (fixed) {
             arrow::UInt64Builder builder;
@@ -221,36 +236,45 @@ Y_UNIT_TEST_SUITE(TPgCodegen) {
         PgFuncImpl(EKernelFlavor::Ideal, true, true);
     }
 
-    Y_UNIT_TEST(PgFixedFuncCpp) {
-        PgFuncImpl(EKernelFlavor::Cpp, false, true);
-        PgFuncImpl(EKernelFlavor::Cpp, true, true);
-    }
-
     Y_UNIT_TEST(PgFixedFuncDefArg) {
         PgFuncImpl(EKernelFlavor::DefArg, false, true);
         PgFuncImpl(EKernelFlavor::DefArg, true, true);
     }
 
-#if defined(NDEBUG) && !defined(_asan_enabled_)
+    Y_UNIT_TEST(PgFixedFuncIndirect) {
+        PgFuncImpl(EKernelFlavor::Indirect, false, true);
+        PgFuncImpl(EKernelFlavor::Indirect, true, true);
+    }    
+
+#if !defined(USE_SLOW_PG_KERNELS)
+    Y_UNIT_TEST(PgFixedFuncCpp) {
+        PgFuncImpl(EKernelFlavor::Cpp, false, true);
+        PgFuncImpl(EKernelFlavor::Cpp, true, true);
+    }
+
     Y_UNIT_TEST(PgFixedFuncBC) {
         PgFuncImpl(EKernelFlavor::BitCode, false, true);
         PgFuncImpl(EKernelFlavor::BitCode, true, true);
     }
-#endif
+#endif    
 
     Y_UNIT_TEST(PgStrFuncIdeal) {
-        PgFuncImpl(EKernelFlavor::DefArg, false, false);
+        PgFuncImpl(EKernelFlavor::Ideal, false, false);
     }        
 
-    Y_UNIT_TEST(PgStrFuncCpp) {
-        PgFuncImpl(EKernelFlavor::Cpp, false, false);
-    }
-
     Y_UNIT_TEST(PgStrFuncDefArg) {
         PgFuncImpl(EKernelFlavor::DefArg, false, false);
     }    
 
-#if defined(NDEBUG) && !defined(_asan_enabled_)
+    Y_UNIT_TEST(PgStrFuncIndirect) {
+        PgFuncImpl(EKernelFlavor::Indirect, false, false);
+    }
+
+#if !defined(USE_SLOW_PG_KERNELS)
+    Y_UNIT_TEST(PgStrFuncCpp) {
+        PgFuncImpl(EKernelFlavor::Cpp, false, false);
+    }
+
     Y_UNIT_TEST(PgStrFuncBC) {
         PgFuncImpl(EKernelFlavor::BitCode, false, false);
     }