duckdb 0.8.2-dev87.0 → 0.9.0

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

@@ -1,4 +1,3 @@
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/operator/add.hpp"
 #include "duckdb/common/operator/multiply.hpp"
 #include "duckdb/common/operator/numeric_binary_operators.hpp"
@@ -35,6 +34,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;
@@ -247,23 +249,22 @@ unique_ptr<FunctionData> BindDecimalAddSubtract(ClientContext &context, ScalarFu
 	return std::move(bind_data);
 }
 
-static void SerializeDecimalArithmetic(FieldWriter &writer, const FunctionData *bind_data_p,
+static void SerializeDecimalArithmetic(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
                                        const ScalarFunction &function) {
 	auto &bind_data = bind_data_p->Cast<DecimalArithmeticBindData>();
-	writer.WriteField(bind_data.check_overflow);
-	writer.WriteSerializable(function.return_type);
-	writer.WriteRegularSerializableList(function.arguments);
+	serializer.WriteProperty(100, "check_overflow", bind_data.check_overflow);
+	serializer.WriteProperty(101, "return_type", function.return_type);
+	serializer.WriteProperty(102, "arguments", function.arguments);
 }
 
 // TODO this is partially duplicated from the bind
 template <class OP, class OPOVERFLOWCHECK, bool IS_SUBTRACT = false>
-unique_ptr<FunctionData> DeserializeDecimalArithmetic(PlanDeserializationState &state, FieldReader &reader,
-                                                      ScalarFunction &bound_function) {
-	// re-change the function pointers
-	auto check_overflow = reader.ReadRequired<bool>();
-	auto return_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	auto arguments = reader.template ReadRequiredSerializableList<LogicalType, LogicalType>();
+unique_ptr<FunctionData> DeserializeDecimalArithmetic(Deserializer &deserializer, ScalarFunction &bound_function) {
 
+	//	// re-change the function pointers
+	auto check_overflow = deserializer.ReadProperty<bool>(100, "check_overflow");
+	auto return_type = deserializer.ReadProperty<LogicalType>(101, "return_type");
+	auto arguments = deserializer.ReadProperty<vector<LogicalType>>(102, "arguments");
 	if (check_overflow) {
 		bound_function.function = GetScalarBinaryFunction<OPOVERFLOWCHECK>(return_type.InternalType());
 	} else {
@@ -302,7 +303,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 +565,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 +769,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/strftime_format.cpp

@@ -26,6 +26,8 @@ idx_t StrfTimepecifierSize(StrTimeSpecifier specifier) {
 	case StrTimeSpecifier::WEEK_NUMBER_PADDED_SUN_FIRST:
 	case StrTimeSpecifier::WEEK_NUMBER_PADDED_MON_FIRST:
 		return 2;
+	case StrTimeSpecifier::NANOSECOND_PADDED:
+		return 9;
 	case StrTimeSpecifier::MICROSECOND_PADDED:
 		return 6;
 	case StrTimeSpecifier::MILLISECOND_PADDED:
@@ -183,9 +185,15 @@ char *StrfTimeFormat::WritePadded3(char *target, uint32_t value) {
 	}
 }
 
-// write a value in the range of 0..999999 padded to 6 digits
+// write a value in the range of 0..999999... padded to the given number of digits
 char *StrfTimeFormat::WritePadded(char *target, uint32_t value, size_t padding) {
-	D_ASSERT(padding % 2 == 0);
+	D_ASSERT(padding > 1);
+	if (padding % 2) {
+		int decimals = value % 1000;
+		WritePadded3(target + padding - 3, decimals);
+		value /= 1000;
+		padding -= 3;
+	}
 	for (size_t i = 0; i < padding / 2; i++) {
 		int decimals = value % 100;
 		WritePadded2(target + padding - 2 * (i + 1), decimals);
@@ -309,11 +317,14 @@ char *StrfTimeFormat::WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t
 	case StrTimeSpecifier::SECOND_PADDED:
 		target = WritePadded2(target, data[5]);
 		break;
+	case StrTimeSpecifier::NANOSECOND_PADDED:
+		target = WritePadded(target, data[6] * Interval::NANOS_PER_MICRO, 9);
+		break;
 	case StrTimeSpecifier::MICROSECOND_PADDED:
 		target = WritePadded(target, data[6], 6);
 		break;
 	case StrTimeSpecifier::MILLISECOND_PADDED:
-		target = WritePadded3(target, data[6] / 1000);
+		target = WritePadded3(target, data[6] / Interval::MICROS_PER_MSEC);
 		break;
 	case StrTimeSpecifier::UTC_OFFSET: {
 		*target++ = (data[7] < 0) ? '-' : '+';
@@ -516,6 +527,9 @@ string StrTimeFormat::ParseFormatSpecifier(const string &format_string, StrTimeF
 				case 'S':
 					specifier = StrTimeSpecifier::SECOND_PADDED;
 					break;
+				case 'n':
+					specifier = StrTimeSpecifier::NANOSECOND_PADDED;
+					break;
 				case 'f':
 					specifier = StrTimeSpecifier::MICROSECOND_PADDED;
 					break;
@@ -660,6 +674,8 @@ int StrpTimeFormat::NumericSpecifierWidth(StrTimeSpecifier specifier) {
 		return 4;
 	case StrTimeSpecifier::MICROSECOND_PADDED:
 		return 6;
+	case StrTimeSpecifier::NANOSECOND_PADDED:
+		return 9;
 	default:
 		return -1;
 	}
@@ -668,7 +684,7 @@ int StrpTimeFormat::NumericSpecifierWidth(StrTimeSpecifier specifier) {
 enum class TimeSpecifierAMOrPM : uint8_t { TIME_SPECIFIER_NONE = 0, TIME_SPECIFIER_AM = 1, TIME_SPECIFIER_PM = 2 };
 
 int32_t StrpTimeFormat::TryParseCollection(const char *data, idx_t &pos, idx_t size, const string_t collection[],
-                                           idx_t collection_count) {
+                                           idx_t collection_count) const {
 	for (idx_t c = 0; c < collection_count; c++) {
 		auto &entry = collection[c];
 		auto entry_data = entry.GetData();
@@ -695,7 +711,7 @@ int32_t StrpTimeFormat::TryParseCollection(const char *data, idx_t &pos, idx_t s
 }
 
 //! Parses a timestamp using the given specifier
-bool StrpTimeFormat::Parse(string_t str, ParseResult &result) {
+bool StrpTimeFormat::Parse(string_t str, ParseResult &result) const {
 	auto &result_data = result.data;
 	auto &error_message = result.error_message;
 	auto &error_position = result.error_position;
@@ -855,15 +871,20 @@ bool StrpTimeFormat::Parse(string_t str, ParseResult &result) {
 				// seconds
 				result_data[5] = number;
 				break;
+			case StrTimeSpecifier::NANOSECOND_PADDED:
+				D_ASSERT(number < Interval::NANOS_PER_SEC); // enforced by the length of the number
+				// microseconds (rounded)
+				result_data[6] = (number + Interval::NANOS_PER_MICRO / 2) / Interval::NANOS_PER_MICRO;
+				break;
 			case StrTimeSpecifier::MICROSECOND_PADDED:
-				D_ASSERT(number < 1000000ULL); // enforced by the length of the number
-				// milliseconds
+				D_ASSERT(number < Interval::MICROS_PER_SEC); // enforced by the length of the number
+				// microseconds
 				result_data[6] = number;
 				break;
 			case StrTimeSpecifier::MILLISECOND_PADDED:
-				D_ASSERT(number < 1000ULL); // enforced by the length of the number
-				// milliseconds
-				result_data[6] = number * 1000;
+				D_ASSERT(number < Interval::MSECS_PER_SEC); // enforced by the length of the number
+				// microseconds
+				result_data[6] = number * Interval::MICROS_PER_MSEC;
 				break;
 			case StrTimeSpecifier::WEEK_NUMBER_PADDED_SUN_FIRST:
 			case StrTimeSpecifier::WEEK_NUMBER_PADDED_MON_FIRST:
@@ -1146,7 +1167,7 @@ string StrpTimeFormat::ParseResult::FormatError(string_t input, const string &fo
 	                          FormatStrpTimeError(input.GetString(), error_position), error_message);
 }
 
-bool StrpTimeFormat::TryParseDate(string_t input, date_t &result, string &error_message) {
+bool StrpTimeFormat::TryParseDate(string_t input, date_t &result, string &error_message) const {
 	ParseResult parse_result;
 	if (!Parse(input, parse_result)) {
 		error_message = parse_result.FormatError(input, format_specifier);
@@ -1155,7 +1176,7 @@ bool StrpTimeFormat::TryParseDate(string_t input, date_t &result, string &error_
 	return parse_result.TryToDate(result);
 }
 
-bool StrpTimeFormat::TryParseTimestamp(string_t input, timestamp_t &result, string &error_message) {
+bool StrpTimeFormat::TryParseTimestamp(string_t input, timestamp_t &result, string &error_message) const {
 	ParseResult parse_result;
 	if (!Parse(input, parse_result)) {
 		error_message = parse_result.FormatError(input, format_specifier);

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

@@ -196,9 +196,6 @@ static unique_ptr<FunctionData> LikeBindFunction(ClientContext &context, ScalarF
 	D_ASSERT(arguments.size() == 2 || arguments.size() == 3);
 	if (arguments[1]->IsFoldable()) {
 		Value pattern_str = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
-		if (pattern_str.IsNull()) {
-			return nullptr;
-		}
 		return LikeMatcher::CreateLikeMatcher(pattern_str.ToString());
 	}
 	return nullptr;
@@ -504,8 +501,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 +518,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 +535,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/string/suffix.cpp

@@ -41,7 +41,7 @@ ScalarFunction SuffixFun::GetFunction() {
 }
 
 void SuffixFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(GetFunction());
+	set.AddFunction({"suffix", "ends_with"}, GetFunction());
 }
 
 } // 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()),
@@ -270,21 +277,22 @@ bool ExportAggregateFunctionBindData::Equals(const FunctionData &other_p) const
 	return aggregate->Equals(*other.aggregate);
 }
 
-static void ExportStateAggregateSerialize(FieldWriter &writer, const FunctionData *bind_data_p,
+static void ExportStateAggregateSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
                                           const AggregateFunction &function) {
 	throw NotImplementedException("FIXME: export state serialize");
 }
-static unique_ptr<FunctionData> ExportStateAggregateDeserialize(PlanDeserializationState &state, FieldReader &reader,
-                                                                AggregateFunction &bound_function) {
+
+static unique_ptr<FunctionData> ExportStateAggregateDeserialize(Deserializer &deserializer,
+                                                                AggregateFunction &function) {
 	throw NotImplementedException("FIXME: export state deserialize");
 }
 
-static void ExportStateScalarSerialize(FieldWriter &writer, const FunctionData *bind_data_p,
+static void ExportStateScalarSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
                                        const ScalarFunction &function) {
 	throw NotImplementedException("FIXME: export state serialize");
 }
-static unique_ptr<FunctionData> ExportStateScalarDeserialize(PlanDeserializationState &state, FieldReader &reader,
-                                                             ScalarFunction &bound_function) {
+
+static unique_ptr<FunctionData> ExportStateScalarDeserialize(Deserializer &deserializer, ScalarFunction &function) {
 	throw NotImplementedException("FIXME: export state deserialize");
 }
 

package/src/duckdb/src/function/scalar_function.cpp

@@ -26,9 +26,10 @@ ScalarFunction::ScalarFunction(vector<LogicalType> arguments, LogicalType return
 }
 
 bool ScalarFunction::operator==(const ScalarFunction &rhs) const {
-	return CompareScalarFunctionT(rhs.function) && bind == rhs.bind && dependency == rhs.dependency &&
-	       statistics == rhs.statistics;
+	return name == rhs.name && arguments == rhs.arguments && return_type == rhs.return_type && varargs == rhs.varargs &&
+	       bind == rhs.bind && dependency == rhs.dependency && statistics == rhs.statistics;
 }
+
 bool ScalarFunction::operator!=(const ScalarFunction &rhs) const {
 	return !(*this == rhs);
 }
@@ -56,23 +57,6 @@ bool ScalarFunction::Equal(const ScalarFunction &rhs) const {
 	return true; // they are equal
 }
 
-bool ScalarFunction::CompareScalarFunctionT(const scalar_function_t &other) const {
-	typedef void(scalar_function_ptr_t)(DataChunk &, ExpressionState &, Vector &);
-
-	auto func_ptr = (scalar_function_ptr_t **)function.template target<scalar_function_ptr_t *>(); // NOLINT
-	auto other_ptr = (scalar_function_ptr_t **)other.template target<scalar_function_ptr_t *>();   // NOLINT
-
-	// Case the functions were created from lambdas the target will return a nullptr
-	if (!func_ptr && !other_ptr) {
-		return true;
-	}
-	if (func_ptr == nullptr || other_ptr == nullptr) {
-		// scalar_function_t (std::functions) from lambdas cannot be compared
-		return false;
-	}
-	return CastPointerToValue(*func_ptr) == CastPointerToValue(*other_ptr);
-}
-
 void ScalarFunction::NopFunction(DataChunk &input, ExpressionState &state, Vector &result) {
 	D_ASSERT(input.ColumnCount() >= 1);
 	result.Reference(input.data[0]);

package/src/duckdb/src/function/scalar_macro_function.cpp

@@ -49,14 +49,4 @@ string ScalarMacroFunction::ToSQL(const string &schema, const string &name) cons
 	return MacroFunction::ToSQL(schema, name) + StringUtil::Format("(%s);", expression_copy->ToString());
 }
 
-void ScalarMacroFunction::SerializeInternal(FieldWriter &writer) const {
-	writer.WriteSerializable(*expression);
-}
-
-unique_ptr<MacroFunction> ScalarMacroFunction::Deserialize(FieldReader &reader) {
-	auto result = make_uniq<ScalarMacroFunction>();
-	result->expression = reader.ReadRequiredSerializable<ParsedExpression>();
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/function/table/arrow/arrow_duck_schema.cpp

@@ -0,0 +1,57 @@
+#include "duckdb/function/table/arrow/arrow_duck_schema.hpp"
+#include "duckdb/common/arrow/arrow.hpp"
+#include "duckdb/common/exception.hpp"
+
+namespace duckdb {
+
+void ArrowTableType::AddColumn(idx_t index, unique_ptr<ArrowType> type) {
+	D_ASSERT(arrow_convert_data.find(index) == arrow_convert_data.end());
+	arrow_convert_data.emplace(std::make_pair(index, std::move(type)));
+}
+
+const arrow_column_map_t &ArrowTableType::GetColumns() const {
+	return arrow_convert_data;
+}
+
+void ArrowType::AddChild(unique_ptr<ArrowType> child) {
+	children.emplace_back(std::move(child));
+}
+
+void ArrowType::AssignChildren(vector<unique_ptr<ArrowType>> children) {
+	D_ASSERT(this->children.empty());
+	this->children = std::move(children);
+}
+
+void ArrowType::SetDictionary(unique_ptr<ArrowType> dictionary) {
+	D_ASSERT(!this->dictionary_type);
+	dictionary_type = std::move(dictionary);
+}
+
+const ArrowType &ArrowType::GetDictionary() const {
+	D_ASSERT(dictionary_type);
+	return *dictionary_type;
+}
+
+const LogicalType &ArrowType::GetDuckType() const {
+	return type;
+}
+
+ArrowVariableSizeType ArrowType::GetSizeType() const {
+	return size_type;
+}
+
+ArrowDateTimeType ArrowType::GetDateTimeType() const {
+	return date_time_precision;
+}
+
+const ArrowType &ArrowType::operator[](idx_t index) const {
+	D_ASSERT(index < children.size());
+	return *children[index];
+}
+
+idx_t ArrowType::FixedSize() const {
+	D_ASSERT(size_type == ArrowVariableSizeType::FIXED_SIZE);
+	return fixed_size;
+}
+
+} // namespace duckdb