duckdb 0.8.2-dev33.0 → 0.8.2-dev3300.0

package/src/duckdb/src/function/scalar/compressed_materialization/compress_string.cpp

@@ -0,0 +1,249 @@
+#include "duckdb/common/bswap.hpp"
+#include "duckdb/function/scalar/compressed_materialization_functions.hpp"
+
+namespace duckdb {
+
+static string StringCompressFunctionName(const LogicalType &result_type) {
+	return StringUtil::Format("__internal_compress_string_%s",
+	                          StringUtil::Lower(LogicalTypeIdToString(result_type.id())));
+}
+
+template <idx_t LENGTH>
+static inline void TemplatedReverseMemCpy(const data_ptr_t __restrict &dest, const const_data_ptr_t __restrict &src) {
+	for (idx_t i = 0; i < LENGTH; i++) {
+		dest[i] = src[LENGTH - 1 - i];
+	}
+}
+
+static inline void ReverseMemCpy(const data_ptr_t __restrict &dest, const const_data_ptr_t __restrict &src,
+                                 const idx_t &length) {
+	for (idx_t i = 0; i < length; i++) {
+		dest[i] = src[length - 1 - i];
+	}
+}
+
+template <class RESULT_TYPE>
+static inline RESULT_TYPE StringCompressInternal(const string_t &input) {
+	RESULT_TYPE result;
+	const auto result_ptr = data_ptr_cast(&result);
+	if (sizeof(RESULT_TYPE) <= string_t::INLINE_LENGTH) {
+		TemplatedReverseMemCpy<sizeof(RESULT_TYPE)>(result_ptr, const_data_ptr_cast(input.GetPrefix()));
+	} else if (input.IsInlined()) {
+		static constexpr auto REMAINDER = sizeof(RESULT_TYPE) - string_t::INLINE_LENGTH;
+		TemplatedReverseMemCpy<string_t::INLINE_LENGTH>(result_ptr + REMAINDER, const_data_ptr_cast(input.GetPrefix()));
+		memset(result_ptr, '\0', REMAINDER);
+	} else {
+		const auto remainder = sizeof(RESULT_TYPE) - input.GetSize();
+		ReverseMemCpy(result_ptr + remainder, data_ptr_cast(input.GetPointer()), input.GetSize());
+		memset(result_ptr, '\0', remainder);
+	}
+	result_ptr[0] = input.GetSize();
+	return result;
+}
+
+template <class RESULT_TYPE>
+static inline RESULT_TYPE StringCompress(const string_t &input) {
+	D_ASSERT(input.GetSize() < sizeof(RESULT_TYPE));
+	return StringCompressInternal<RESULT_TYPE>(input);
+}
+
+template <class RESULT_TYPE>
+static inline RESULT_TYPE MiniStringCompress(const string_t &input) {
+	if (sizeof(RESULT_TYPE) <= string_t::INLINE_LENGTH) {
+		return input.GetSize() + *const_data_ptr_cast(input.GetPrefix());
+	} else if (input.GetSize() == 0) {
+		return 0;
+	} else {
+		return input.GetSize() + *const_data_ptr_cast(input.GetPointer());
+	}
+}
+
+template <>
+inline uint8_t StringCompress(const string_t &input) {
+	D_ASSERT(input.GetSize() <= sizeof(uint8_t));
+	return MiniStringCompress<uint8_t>(input);
+}
+
+template <class RESULT_TYPE>
+static void StringCompressFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	UnaryExecutor::Execute<string_t, RESULT_TYPE>(args.data[0], result, args.size(), StringCompress<RESULT_TYPE>);
+}
+
+template <class RESULT_TYPE>
+static scalar_function_t GetStringCompressFunction(const LogicalType &result_type) {
+	return StringCompressFunction<RESULT_TYPE>;
+}
+
+static scalar_function_t GetStringCompressFunctionSwitch(const LogicalType &result_type) {
+	switch (result_type.id()) {
+	case LogicalTypeId::UTINYINT:
+		return GetStringCompressFunction<uint8_t>(result_type);
+	case LogicalTypeId::USMALLINT:
+		return GetStringCompressFunction<uint16_t>(result_type);
+	case LogicalTypeId::UINTEGER:
+		return GetStringCompressFunction<uint32_t>(result_type);
+	case LogicalTypeId::UBIGINT:
+		return GetStringCompressFunction<uint64_t>(result_type);
+	case LogicalTypeId::HUGEINT:
+		return GetStringCompressFunction<hugeint_t>(result_type);
+	default:
+		throw InternalException("Unexpected type in GetStringCompressFunctionSwitch");
+	}
+}
+
+static string StringDecompressFunctionName() {
+	return "__internal_decompress_string";
+}
+
+struct StringDecompressLocalState : public FunctionLocalState {
+public:
+	explicit StringDecompressLocalState(ClientContext &context) : allocator(Allocator::Get(context)) {
+	}
+
+	static unique_ptr<FunctionLocalState> Init(ExpressionState &state, const BoundFunctionExpression &expr,
+	                                           FunctionData *bind_data) {
+		return make_uniq<StringDecompressLocalState>(state.GetContext());
+	}
+
+public:
+	ArenaAllocator allocator;
+};
+
+template <class INPUT_TYPE>
+static inline string_t StringDecompress(const INPUT_TYPE &input, ArenaAllocator &allocator) {
+	const auto input_ptr = const_data_ptr_cast(&input);
+	string_t result(input_ptr[0]);
+	if (sizeof(INPUT_TYPE) <= string_t::INLINE_LENGTH) {
+		const auto result_ptr = data_ptr_cast(result.GetPrefixWriteable());
+		TemplatedReverseMemCpy<sizeof(INPUT_TYPE)>(result_ptr, input_ptr);
+		memset(result_ptr + sizeof(INPUT_TYPE) - 1, '\0', string_t::INLINE_LENGTH - sizeof(INPUT_TYPE) + 1);
+	} else if (result.GetSize() <= string_t::INLINE_LENGTH) {
+		static constexpr auto REMAINDER = sizeof(INPUT_TYPE) - string_t::INLINE_LENGTH;
+		const auto result_ptr = data_ptr_cast(result.GetPrefixWriteable());
+		TemplatedReverseMemCpy<string_t::INLINE_LENGTH>(result_ptr, input_ptr + REMAINDER);
+	} else {
+		result.SetPointer(char_ptr_cast(allocator.Allocate(sizeof(INPUT_TYPE))));
+		TemplatedReverseMemCpy<sizeof(INPUT_TYPE)>(data_ptr_cast(result.GetPointer()), input_ptr);
+		memcpy(result.GetPrefixWriteable(), result.GetPointer(), string_t::PREFIX_LENGTH);
+	}
+	return result;
+}
+
+template <class INPUT_TYPE>
+static inline string_t MiniStringDecompress(const INPUT_TYPE &input, ArenaAllocator &allocator) {
+	if (input == 0) {
+		string_t result(uint32_t(0));
+		memset(result.GetPrefixWriteable(), '\0', string_t::INLINE_BYTES);
+		return result;
+	}
+
+	string_t result(1);
+	if (sizeof(INPUT_TYPE) <= string_t::INLINE_LENGTH) {
+		memset(result.GetPrefixWriteable(), '\0', string_t::INLINE_BYTES);
+		*data_ptr_cast(result.GetPrefixWriteable()) = input - 1;
+	} else {
+		result.SetPointer(char_ptr_cast(allocator.Allocate(1)));
+		*data_ptr_cast(result.GetPointer()) = input - 1;
+		memset(result.GetPrefixWriteable(), '\0', string_t::PREFIX_LENGTH);
+		*result.GetPrefixWriteable() = *result.GetPointer();
+	}
+	return result;
+}
+
+template <>
+inline string_t StringDecompress(const uint8_t &input, ArenaAllocator &allocator) {
+	return MiniStringDecompress<uint8_t>(input, allocator);
+}
+
+template <class INPUT_TYPE>
+static void StringDecompressFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &allocator = ExecuteFunctionState::GetFunctionState(state)->Cast<StringDecompressLocalState>().allocator;
+	allocator.Reset();
+	UnaryExecutor::Execute<INPUT_TYPE, string_t>(args.data[0], result, args.size(), [&](const INPUT_TYPE &input) {
+		return StringDecompress<INPUT_TYPE>(input, allocator);
+	});
+}
+
+template <class INPUT_TYPE>
+static scalar_function_t GetStringDecompressFunction(const LogicalType &input_type) {
+	return StringDecompressFunction<INPUT_TYPE>;
+}
+
+static scalar_function_t GetStringDecompressFunctionSwitch(const LogicalType &input_type) {
+	switch (input_type.id()) {
+	case LogicalTypeId::UTINYINT:
+		return GetStringDecompressFunction<uint8_t>(input_type);
+	case LogicalTypeId::USMALLINT:
+		return GetStringDecompressFunction<uint16_t>(input_type);
+	case LogicalTypeId::UINTEGER:
+		return GetStringDecompressFunction<uint32_t>(input_type);
+	case LogicalTypeId::UBIGINT:
+		return GetStringDecompressFunction<uint64_t>(input_type);
+	case LogicalTypeId::HUGEINT:
+		return GetStringDecompressFunction<hugeint_t>(input_type);
+	default:
+		throw InternalException("Unexpected type in GetStringDecompressFunctionSwitch");
+	}
+}
+
+static void CMStringCompressSerialize(FieldWriter &writer, const FunctionData *bind_data_p,
+                                      const ScalarFunction &function) {
+	writer.WriteRegularSerializableList(function.arguments);
+	writer.WriteSerializable(function.return_type);
+}
+
+unique_ptr<FunctionData> CMStringCompressDeserialize(PlanDeserializationState &state, FieldReader &reader,
+                                                     ScalarFunction &function) {
+	function.arguments = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
+	function.function = GetStringCompressFunctionSwitch(reader.ReadRequiredSerializable<LogicalType, LogicalType>());
+	return nullptr;
+}
+
+ScalarFunction CMStringCompressFun::GetFunction(const LogicalType &result_type) {
+	ScalarFunction result(StringCompressFunctionName(result_type), {LogicalType::VARCHAR}, result_type,
+	                      GetStringCompressFunctionSwitch(result_type), CompressedMaterializationFunctions::Bind);
+	result.serialize = CMStringCompressSerialize;
+	result.deserialize = CMStringCompressDeserialize;
+	return result;
+}
+
+void CMStringCompressFun::RegisterFunction(BuiltinFunctions &set) {
+	for (const auto &result_type : CompressedMaterializationFunctions::StringTypes()) {
+		set.AddFunction(CMStringCompressFun::GetFunction(result_type));
+	}
+}
+
+static void CMStringDecompressSerialize(FieldWriter &writer, const FunctionData *bind_data_p,
+                                        const ScalarFunction &function) {
+	writer.WriteRegularSerializableList(function.arguments);
+}
+
+unique_ptr<FunctionData> CMStringDecompressDeserialize(PlanDeserializationState &state, FieldReader &reader,
+                                                       ScalarFunction &function) {
+	function.arguments = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
+	function.function = GetStringDecompressFunctionSwitch(function.arguments[0]);
+	return nullptr;
+}
+
+ScalarFunction CMStringDecompressFun::GetFunction(const LogicalType &input_type) {
+	ScalarFunction result(StringDecompressFunctionName(), {input_type}, LogicalType::VARCHAR,
+	                      GetStringDecompressFunctionSwitch(input_type), CompressedMaterializationFunctions::Bind,
+	                      nullptr, nullptr, StringDecompressLocalState::Init);
+	result.serialize = CMStringDecompressSerialize;
+	result.deserialize = CMStringDecompressDeserialize;
+	return result;
+}
+
+static ScalarFunctionSet GetStringDecompressFunctionSet() {
+	ScalarFunctionSet set(StringDecompressFunctionName());
+	for (const auto &input_type : CompressedMaterializationFunctions::StringTypes()) {
+		set.AddFunction(CMStringDecompressFun::GetFunction(input_type));
+	}
+	return set;
+}
+
+void CMStringDecompressFun::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction(GetStringDecompressFunctionSet());
+}
+
+} // namespace duckdb

package/src/duckdb/src/function/scalar/compressed_materialization_functions.cpp

@@ -0,0 +1,29 @@
+#include "duckdb/function/scalar/compressed_materialization_functions.hpp"
+
+namespace duckdb {
+
+const vector<LogicalType> CompressedMaterializationFunctions::IntegralTypes() {
+	return {LogicalType::UTINYINT, LogicalType::USMALLINT, LogicalType::UINTEGER, LogicalType::UBIGINT};
+}
+
+const vector<LogicalType> CompressedMaterializationFunctions::StringTypes() {
+	return {LogicalType::UTINYINT, LogicalType::USMALLINT, LogicalType::UINTEGER, LogicalType::UBIGINT,
+	        LogicalType::HUGEINT};
+}
+
+// LCOV_EXCL_START
+unique_ptr<FunctionData> CompressedMaterializationFunctions::Bind(ClientContext &context,
+                                                                  ScalarFunction &bound_function,
+                                                                  vector<unique_ptr<Expression>> &arguments) {
+	throw BinderException("Compressed materialization functions are for internal use only!");
+}
+// LCOV_EXCL_STOP
+
+void BuiltinFunctions::RegisterCompressedMaterializationFunctions() {
+	Register<CMIntegralCompressFun>();
+	Register<CMIntegralDecompressFun>();
+	Register<CMStringCompressFun>();
+	Register<CMStringDecompressFun>();
+}
+
+} // namespace duckdb

package/src/duckdb/src/function/scalar/list/list_resize.cpp

@@ -0,0 +1,162 @@
+#include "duckdb/common/types/data_chunk.hpp"
+#include "duckdb/function/scalar/nested_functions.hpp"
+#include "duckdb/function/scalar_function.hpp"
+#include "duckdb/function/built_in_functions.hpp"
+
+namespace duckdb {
+
+void ListResizeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	D_ASSERT(args.data[1].GetType().id() == LogicalTypeId::UBIGINT);
+	if (result.GetType().id() == LogicalTypeId::SQLNULL) {
+		FlatVector::SetNull(result, 0, true);
+		return;
+	}
+	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
+	auto count = args.size();
+
+	result.SetVectorType(VectorType::FLAT_VECTOR);
+
+	auto &lists = args.data[0];
+	auto &child = ListVector::GetEntry(args.data[0]);
+	auto &new_sizes = args.data[1];
+
+	UnifiedVectorFormat list_data;
+	lists.ToUnifiedFormat(count, list_data);
+	auto list_entries = UnifiedVectorFormat::GetData<list_entry_t>(list_data);
+
+	UnifiedVectorFormat new_size_data;
+	new_sizes.ToUnifiedFormat(count, new_size_data);
+	auto new_size_entries = UnifiedVectorFormat::GetData<int64_t>(new_size_data);
+
+	UnifiedVectorFormat child_data;
+	child.ToUnifiedFormat(count, child_data);
+
+	// Find the new size of the result child vector
+	idx_t new_child_size = 0;
+	for (idx_t i = 0; i < count; i++) {
+		auto index = new_size_data.sel->get_index(i);
+		if (new_size_data.validity.RowIsValid(index)) {
+			new_child_size += new_size_entries[index];
+		}
+	}
+
+	// Create the default vector if it exists
+	UnifiedVectorFormat default_data;
+	optional_ptr<Vector> default_vector;
+	if (args.ColumnCount() == 3) {
+		default_vector = &args.data[2];
+		default_vector->ToUnifiedFormat(count, default_data);
+		default_vector->SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
+
+	ListVector::Reserve(result, new_child_size);
+	ListVector::SetListSize(result, new_child_size);
+
+	auto result_entries = FlatVector::GetData<list_entry_t>(result);
+	auto &result_child = ListVector::GetEntry(result);
+
+	// for each lists in the args
+	idx_t result_child_offset = 0;
+	for (idx_t args_index = 0; args_index < count; args_index++) {
+		auto l_index = list_data.sel->get_index(args_index);
+		auto new_index = new_size_data.sel->get_index(args_index);
+
+		// set null if lists is null
+		if (!list_data.validity.RowIsValid(l_index)) {
+			FlatVector::SetNull(result, args_index, true);
+			continue;
+		}
+
+		idx_t new_size_entry = 0;
+		if (new_size_data.validity.RowIsValid(new_index)) {
+			new_size_entry = new_size_entries[new_index];
+		}
+
+		// find the smallest size between lists and new_sizes
+		auto values_to_copy = MinValue<idx_t>(list_entries[l_index].length, new_size_entry);
+
+		// set the result entry
+		result_entries[args_index].offset = result_child_offset;
+		result_entries[args_index].length = new_size_entry;
+
+		// copy the values from the child vector
+		VectorOperations::Copy(child, result_child, list_entries[l_index].offset + values_to_copy,
+		                       list_entries[l_index].offset, result_child_offset);
+		result_child_offset += values_to_copy;
+
+		// set default value if it exists
+		idx_t def_index = 0;
+		if (args.ColumnCount() == 3) {
+			def_index = default_data.sel->get_index(args_index);
+		}
+
+		// if the new size is larger than the old size, fill in the default value
+		if (values_to_copy < new_size_entry) {
+			if (default_vector && default_data.validity.RowIsValid(def_index)) {
+				VectorOperations::Copy(*default_vector, result_child, new_size_entry - values_to_copy, def_index,
+				                       result_child_offset);
+				result_child_offset += new_size_entry - values_to_copy;
+			} else {
+				for (idx_t j = values_to_copy; j < new_size_entry; j++) {
+					FlatVector::SetNull(result_child, result_child_offset, true);
+					result_child_offset++;
+				}
+			}
+		}
+	}
+
+	if (args.AllConstant()) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
+}
+
+static unique_ptr<FunctionData> ListResizeBind(ClientContext &context, ScalarFunction &bound_function,
+                                               vector<unique_ptr<Expression>> &arguments) {
+	D_ASSERT(bound_function.arguments.size() == 2 || arguments.size() == 3);
+	bound_function.arguments[1] = LogicalType::UBIGINT;
+
+	// first argument is constant NULL
+	if (arguments[0]->return_type == LogicalType::SQLNULL) {
+		bound_function.arguments[0] = LogicalType::SQLNULL;
+		bound_function.return_type = LogicalType::SQLNULL;
+		return make_uniq<VariableReturnBindData>(bound_function.return_type);
+	}
+
+	// prepared statements
+	if (arguments[0]->return_type == LogicalType::UNKNOWN) {
+		bound_function.return_type = arguments[0]->return_type;
+		return make_uniq<VariableReturnBindData>(bound_function.return_type);
+	}
+
+	// default type does not match list type
+	if (bound_function.arguments.size() == 3 &&
+	    ListType::GetChildType(arguments[0]->return_type) != arguments[2]->return_type &&
+	    arguments[2]->return_type != LogicalTypeId::SQLNULL) {
+		bound_function.arguments[2] = ListType::GetChildType(arguments[0]->return_type);
+	}
+
+	bound_function.return_type = arguments[0]->return_type;
+	return make_uniq<VariableReturnBindData>(bound_function.return_type);
+}
+
+void ListResizeFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunction sfun({LogicalType::LIST(LogicalTypeId::ANY), LogicalTypeId::ANY},
+	                    LogicalType::LIST(LogicalTypeId::ANY), ListResizeFunction, ListResizeBind);
+	sfun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+
+	ScalarFunction dfun({LogicalType::LIST(LogicalTypeId::ANY), LogicalTypeId::ANY, LogicalTypeId::ANY},
+	                    LogicalType::LIST(LogicalTypeId::ANY), ListResizeFunction, ListResizeBind);
+	dfun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+
+	ScalarFunctionSet list_resize("list_resize");
+	list_resize.AddFunction(sfun);
+	list_resize.AddFunction(dfun);
+	set.AddFunction(list_resize);
+
+	ScalarFunctionSet array_resize("array_resize");
+	array_resize.AddFunction(sfun);
+	array_resize.AddFunction(dfun);
+	set.AddFunction(array_resize);
+}
+
+} // namespace duckdb

package/src/duckdb/src/function/scalar/nested_functions.cpp

@@ -8,6 +8,7 @@ void BuiltinFunctions::RegisterNestedFunctions() {
 	Register<ListContainsFun>();
 	Register<ListPositionFun>();
 	Register<ListExtractFun>();
+	Register<ListResizeFun>();
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/scalar/operators/add.cpp

@@ -160,6 +160,15 @@ bool TryAddOperator::Operation(int64_t left, int64_t right, int64_t &result) {
 	return true;
 }
 
+template <>
+bool TryAddOperator::Operation(hugeint_t left, hugeint_t right, hugeint_t &result) {
+	if (!Hugeint::AddInPlace(left, right)) {
+		return false;
+	}
+	result = left;
+	return true;
+}
+
 //===--------------------------------------------------------------------===//
 // add decimal with overflow check
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/function/scalar/operators/arithmetic.cpp

@@ -35,6 +35,9 @@ static scalar_function_t GetScalarIntegerFunction(PhysicalType type) {
 	case PhysicalType::INT64:
 		function = &ScalarFunction::BinaryFunction<int64_t, int64_t, int64_t, OP>;
 		break;
+	case PhysicalType::INT128:
+		function = &ScalarFunction::BinaryFunction<hugeint_t, hugeint_t, hugeint_t, OP>;
+		break;
 	case PhysicalType::UINT8:
 		function = &ScalarFunction::BinaryFunction<uint8_t, uint8_t, uint8_t, OP>;
 		break;
@@ -302,7 +305,7 @@ ScalarFunction AddFun::GetFunction(const LogicalType &left_type, const LogicalTy
 			function.serialize = SerializeDecimalArithmetic;
 			function.deserialize = DeserializeDecimalArithmetic<AddOperator, DecimalAddOverflowCheck>;
 			return function;
-		} else if (left_type.IsIntegral() && left_type.id() != LogicalTypeId::HUGEINT) {
+		} else if (left_type.IsIntegral()) {
 			return ScalarFunction("+", {left_type, right_type}, left_type,
 			                      GetScalarIntegerFunction<AddOperatorOverflowCheck>(left_type.InternalType()), nullptr,
 			                      nullptr, PropagateNumericStats<TryAddOperator, AddPropagateStatistics, AddOperator>);
@@ -564,7 +567,7 @@ ScalarFunction SubtractFun::GetFunction(const LogicalType &left_type, const Logi
 			function.serialize = SerializeDecimalArithmetic;
 			function.deserialize = DeserializeDecimalArithmetic<SubtractOperator, DecimalSubtractOverflowCheck>;
 			return function;
-		} else if (left_type.IsIntegral() && left_type.id() != LogicalTypeId::HUGEINT) {
+		} else if (left_type.IsIntegral()) {
 			return ScalarFunction(
 			    "-", {left_type, right_type}, left_type,
 			    GetScalarIntegerFunction<SubtractOperatorOverflowCheck>(left_type.InternalType()), nullptr, nullptr,
@@ -768,7 +771,7 @@ void MultiplyFun::RegisterFunction(BuiltinFunctions &set) {
 			function.serialize = SerializeDecimalArithmetic;
 			function.deserialize = DeserializeDecimalArithmetic<MultiplyOperator, DecimalMultiplyOverflowCheck>;
 			functions.AddFunction(function);
-		} else if (TypeIsIntegral(type.InternalType()) && type.id() != LogicalTypeId::HUGEINT) {
+		} else if (TypeIsIntegral(type.InternalType())) {
 			functions.AddFunction(ScalarFunction(
 			    {type, type}, type, GetScalarIntegerFunction<MultiplyOperatorOverflowCheck>(type.InternalType()),
 			    nullptr, nullptr,

package/src/duckdb/src/function/scalar/string/like.cpp

@@ -504,8 +504,7 @@ static void RegularLikeFunction(DataChunk &input, ExpressionState &state, Vector
 }
 void LikeFun::RegisterFunction(BuiltinFunctions &set) {
 	// like
-	set.AddFunction(ScalarFunction("~~", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
-	                               RegularLikeFunction<LikeOperator, false>, LikeBindFunction));
+	set.AddFunction(GetLikeFunction());
 	// not like
 	set.AddFunction(ScalarFunction("!~~", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
 	                               RegularLikeFunction<NotLikeOperator, true>, LikeBindFunction));
@@ -522,9 +521,13 @@ void LikeFun::RegisterFunction(BuiltinFunctions &set) {
 	                               nullptr, ILikePropagateStats<NotILikeOperatorASCII>));
 }
 
+ScalarFunction LikeFun::GetLikeFunction() {
+	return ScalarFunction("~~", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN,
+	                      RegularLikeFunction<LikeOperator, false>, LikeBindFunction);
+}
+
 void LikeEscapeFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction({"like_escape"}, ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
-	                                                LogicalType::BOOLEAN, LikeEscapeFunction<LikeEscapeOperator>));
+	set.AddFunction(GetLikeEscapeFun());
 	set.AddFunction({"not_like_escape"},
 	                ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
 	                               LogicalType::BOOLEAN, LikeEscapeFunction<NotLikeEscapeOperator>));
@@ -535,4 +538,9 @@ void LikeEscapeFun::RegisterFunction(BuiltinFunctions &set) {
 	                ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
 	                               LogicalType::BOOLEAN, LikeEscapeFunction<NotILikeEscapeOperator>));
 }
+
+ScalarFunction LikeEscapeFun::GetLikeEscapeFun() {
+	return ScalarFunction("like_escape", {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR},
+	                      LogicalType::BOOLEAN, LikeEscapeFunction<LikeEscapeOperator>);
+}
 } // namespace duckdb

package/src/duckdb/src/function/scalar/system/aggregate_export.cpp

@@ -1,11 +1,11 @@
 #include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
+#include "duckdb/function/function_binder.hpp"
 #include "duckdb/function/scalar/generic_functions.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/function/function_binder.hpp"
 
 namespace duckdb {
 
@@ -39,11 +39,14 @@ struct CombineState : public FunctionLocalState {
 	unsafe_unique_array<data_t> state_buffer0, state_buffer1;
 	Vector state_vector0, state_vector1;
 
+	ArenaAllocator allocator;
+
 	explicit CombineState(idx_t state_size_p)
 	    : state_size(state_size_p), state_buffer0(make_unsafe_uniq_array<data_t>(state_size_p)),
 	      state_buffer1(make_unsafe_uniq_array<data_t>(state_size_p)),
 	      state_vector0(Value::POINTER(CastPointerToValue(state_buffer0.get()))),
-	      state_vector1(Value::POINTER(CastPointerToValue(state_buffer1.get()))) {
+	      state_vector1(Value::POINTER(CastPointerToValue(state_buffer1.get()))),
+	      allocator(Allocator::DefaultAllocator()) {
 	}
 };
 
@@ -58,10 +61,12 @@ struct FinalizeState : public FunctionLocalState {
 	unsafe_unique_array<data_t> state_buffer;
 	Vector addresses;
 
+	ArenaAllocator allocator;
+
 	explicit FinalizeState(idx_t state_size_p)
 	    : state_size(state_size_p),
 	      state_buffer(make_unsafe_uniq_array<data_t>(STANDARD_VECTOR_SIZE * AlignValue(state_size_p))),
-	      addresses(LogicalType::POINTER) {
+	      addresses(LogicalType::POINTER), allocator(Allocator::DefaultAllocator()) {
 	}
 };
 
@@ -74,6 +79,7 @@ static unique_ptr<FunctionLocalState> InitFinalizeState(ExpressionState &state,
 static void AggregateStateFinalize(DataChunk &input, ExpressionState &state_p, Vector &result) {
 	auto &bind_data = ExportAggregateBindData::GetFrom(state_p);
 	auto &local_state = ExecuteFunctionState::GetFunctionState(state_p)->Cast<FinalizeState>();
+	local_state.allocator.Reset();
 
 	D_ASSERT(bind_data.state_size == bind_data.aggr.state_size());
 	D_ASSERT(input.data.size() == 1);
@@ -100,7 +106,7 @@ static void AggregateStateFinalize(DataChunk &input, ExpressionState &state_p, V
 		state_vec_ptr[i] = data_ptr_cast(target_ptr);
 	}
 
-	AggregateInputData aggr_input_data(nullptr, Allocator::DefaultAllocator());
+	AggregateInputData aggr_input_data(nullptr, local_state.allocator);
 	bind_data.aggr.finalize(local_state.addresses, aggr_input_data, result, input.size(), 0);
 
 	for (idx_t i = 0; i < input.size(); i++) {
@@ -114,6 +120,7 @@ static void AggregateStateFinalize(DataChunk &input, ExpressionState &state_p, V
 static void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Vector &result) {
 	auto &bind_data = ExportAggregateBindData::GetFrom(state_p);
 	auto &local_state = ExecuteFunctionState::GetFunctionState(state_p)->Cast<CombineState>();
+	local_state.allocator.Reset();
 
 	D_ASSERT(bind_data.state_size == bind_data.aggr.state_size());
 
@@ -164,7 +171,7 @@ static void AggregateStateCombine(DataChunk &input, ExpressionState &state_p, Ve
 		memcpy(local_state.state_buffer0.get(), state0.GetData(), bind_data.state_size);
 		memcpy(local_state.state_buffer1.get(), state1.GetData(), bind_data.state_size);
 
-		AggregateInputData aggr_input_data(nullptr, Allocator::DefaultAllocator());
+		AggregateInputData aggr_input_data(nullptr, local_state.allocator);
 		bind_data.aggr.combine(local_state.state_vector0, local_state.state_vector1, aggr_input_data, 1);
 
 		result_ptr[i] = StringVector::AddStringOrBlob(result, const_char_ptr_cast(local_state.state_buffer1.get()),
@@ -279,6 +286,17 @@ static unique_ptr<FunctionData> ExportStateAggregateDeserialize(PlanDeserializat
 	throw NotImplementedException("FIXME: export state deserialize");
 }
 
+static void ExportStateAggregateFormatSerialize(FormatSerializer &serializer,
+                                                const optional_ptr<FunctionData> bind_data_p,
+                                                const AggregateFunction &function) {
+	throw SerializationException("FIXME: export state serialize");
+}
+
+static unique_ptr<FunctionData> ExportStateAggregateFormatDeserialize(FormatDeserializer &deserializer,
+                                                                      AggregateFunction &function) {
+	throw SerializationException("FIXME: export state deserialize");
+}
+
 static void ExportStateScalarSerialize(FieldWriter &writer, const FunctionData *bind_data_p,
                                        const ScalarFunction &function) {
 	throw NotImplementedException("FIXME: export state serialize");
@@ -288,6 +306,16 @@ static unique_ptr<FunctionData> ExportStateScalarDeserialize(PlanDeserialization
 	throw NotImplementedException("FIXME: export state deserialize");
 }
 
+static void ExportStateScalarFormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+                                             const ScalarFunction &function) {
+	throw SerializationException("FIXME: export state serialize");
+}
+
+static unique_ptr<FunctionData> ExportStateScalarFormatDeserialize(FormatDeserializer &deserializer,
+                                                                   ScalarFunction &function) {
+	throw SerializationException("FIXME: export state deserialize");
+}
+
 unique_ptr<BoundAggregateExpression>
 ExportAggregateFunction::Bind(unique_ptr<BoundAggregateExpression> child_aggregate) {
 	auto &bound_function = child_aggregate->function;
@@ -324,6 +352,8 @@ ExportAggregateFunction::Bind(unique_ptr<BoundAggregateExpression> child_aggrega
 	export_function.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	export_function.serialize = ExportStateAggregateSerialize;
 	export_function.deserialize = ExportStateAggregateDeserialize;
+	export_function.format_serialize = ExportStateAggregateFormatSerialize;
+	export_function.format_deserialize = ExportStateAggregateFormatDeserialize;
 
 	return make_uniq<BoundAggregateExpression>(export_function, std::move(child_aggregate->children),
 	                                           std::move(child_aggregate->filter), std::move(export_bind_data),
@@ -336,6 +366,8 @@ ScalarFunction ExportAggregateFunction::GetFinalize() {
 	result.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	result.serialize = ExportStateScalarSerialize;
 	result.deserialize = ExportStateScalarDeserialize;
+	result.format_serialize = ExportStateScalarFormatSerialize;
+	result.format_deserialize = ExportStateScalarFormatDeserialize;
 	return result;
 }
 
@@ -346,6 +378,8 @@ ScalarFunction ExportAggregateFunction::GetCombine() {
 	result.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	result.serialize = ExportStateScalarSerialize;
 	result.deserialize = ExportStateScalarDeserialize;
+	result.format_serialize = ExportStateScalarFormatSerialize;
+	result.format_deserialize = ExportStateScalarFormatDeserialize;
 	return result;
 }