duckdb 0.8.2-dev33.0 → 0.8.2-dev3334.0

package/src/duckdb/src/core_functions/scalar/list/array_slice.cpp

@@ -1,14 +1,62 @@
 #include "duckdb/core_functions/scalar/list_functions.hpp"
-#include "duckdb/common/pair.hpp"
 #include "duckdb/common/string_util.hpp"
+#include "duckdb/common/swap.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/function/scalar/string_functions.hpp"
-#include "duckdb/parser/expression/bound_expression.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
 
 namespace duckdb {
 
+struct ListSliceBindData : public FunctionData {
+	ListSliceBindData(const LogicalType &return_type_p, bool begin_is_empty_p, bool end_is_empty_p)
+	    : return_type(return_type_p), begin_is_empty(begin_is_empty_p), end_is_empty(end_is_empty_p) {
+	}
+	~ListSliceBindData() override;
+
+	LogicalType return_type;
+
+	bool begin_is_empty;
+	bool end_is_empty;
+
+public:
+	bool Equals(const FunctionData &other_p) const override;
+	unique_ptr<FunctionData> Copy() const override;
+};
+
+ListSliceBindData::~ListSliceBindData() {
+}
+
+bool ListSliceBindData::Equals(const FunctionData &other_p) const {
+	auto &other = other_p.Cast<ListSliceBindData>();
+	return return_type == other.return_type && begin_is_empty == other.begin_is_empty &&
+	       end_is_empty == other.end_is_empty;
+}
+
+unique_ptr<FunctionData> ListSliceBindData::Copy() const {
+	return make_uniq<ListSliceBindData>(return_type, begin_is_empty, end_is_empty);
+}
+
+template <typename INDEX_TYPE>
+static int CalculateSliceLength(idx_t begin, idx_t end, INDEX_TYPE step, bool svalid) {
+	if (step < 0) {
+		step = abs(step);
+	}
+	if (step == 0 && svalid) {
+		throw InvalidInputException("Slice step cannot be zero");
+	}
+	if (step == 1) {
+		return end - begin;
+	} else if (static_cast<idx_t>(step) >= (end - begin)) {
+		return 1;
+	}
+	if ((end - begin) % step != 0) {
+		return (end - begin) / step + 1;
+	}
+	return (end - begin) / step;
+}
+
 template <typename INPUT_TYPE, typename INDEX_TYPE>
 INDEX_TYPE ValueLength(const INPUT_TYPE &value) {
 	return 0;
@@ -20,33 +68,44 @@ int64_t ValueLength(const list_entry_t &value) {
 }
 
 template <>
-int32_t ValueLength(const string_t &value) {
-	return LengthFun::Length<string_t, int32_t>(value);
+int64_t ValueLength(const string_t &value) {
+	return LengthFun::Length<string_t, int64_t>(value);
 }
 
 template <typename INPUT_TYPE, typename INDEX_TYPE>
-bool ClampIndex(INDEX_TYPE &index, const INPUT_TYPE &value) {
-	const auto length = ValueLength<INPUT_TYPE, INDEX_TYPE>(value);
+static void ClampIndex(INDEX_TYPE &index, const INPUT_TYPE &value, const INDEX_TYPE length, bool is_min) {
 	if (index < 0) {
-		if (index < -length) {
-			return false;
-		}
+		index = (!is_min) ? index + 1 : index;
 		index = length + index;
+		return;
 	} else if (index > length) {
 		index = length;
 	}
-	return true;
+	return;
 }
 
 template <typename INPUT_TYPE, typename INDEX_TYPE>
-static bool ClampSlice(const INPUT_TYPE &value, INDEX_TYPE &begin, INDEX_TYPE &end, bool begin_valid, bool end_valid) {
+static bool ClampSlice(const INPUT_TYPE &value, INDEX_TYPE &begin, INDEX_TYPE &end) {
 	// Clamp offsets
-	begin = begin_valid ? begin : 0;
-	begin = (begin > 0) ? begin - 1 : begin;
-	end = end_valid ? end : ValueLength<INPUT_TYPE, INDEX_TYPE>(value);
-	if (!ClampIndex(begin, value) || !ClampIndex(end, value)) {
-		return false;
+	begin = (begin != 0 && begin != (INDEX_TYPE)NumericLimits<int64_t>::Minimum()) ? begin - 1 : begin;
+
+	bool is_min = false;
+	if (begin == (INDEX_TYPE)NumericLimits<int64_t>::Minimum()) {
+		begin++;
+		is_min = true;
+	}
+
+	const auto length = ValueLength<INPUT_TYPE, INDEX_TYPE>(value);
+	if (begin < 0 && -begin > length && end < 0 && -end > length) {
+		begin = 0;
+		end = 0;
+		return true;
 	}
+	if (begin < 0 && -begin > length) {
+		begin = 0;
+	}
+	ClampIndex(begin, value, length, is_min);
+	ClampIndex(end, value, length, false);
 	end = MaxValue<INDEX_TYPE>(begin, end);
 
 	return true;
@@ -65,108 +124,268 @@ list_entry_t SliceValue(Vector &result, list_entry_t input, int64_t begin, int64
 }
 
 template <>
-string_t SliceValue(Vector &result, string_t input, int32_t begin, int32_t end) {
+string_t SliceValue(Vector &result, string_t input, int64_t begin, int64_t end) {
 	// one-based - zero has strange semantics
 	return SubstringFun::SubstringUnicode(result, input, begin + 1, end - begin);
 }
 
 template <typename INPUT_TYPE, typename INDEX_TYPE>
-static void ExecuteSlice(Vector &result, Vector &s, Vector &b, Vector &e, const idx_t count) {
-	if (result.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-		auto rdata = ConstantVector::GetData<INPUT_TYPE>(result);
-		auto sdata = ConstantVector::GetData<INPUT_TYPE>(s);
-		auto bdata = ConstantVector::GetData<INDEX_TYPE>(b);
-		auto edata = ConstantVector::GetData<INDEX_TYPE>(e);
-
-		auto sliced = sdata[0];
-		auto begin = bdata[0];
-		auto end = edata[0];
-
-		auto svalid = !ConstantVector::IsNull(s);
-		auto bvalid = !ConstantVector::IsNull(b);
-		auto evalid = !ConstantVector::IsNull(e);
-
-		// Try to slice
-		if (!svalid || !ClampSlice(sliced, begin, end, bvalid, evalid)) {
-			ConstantVector::SetNull(result, true);
-		} else {
-			rdata[0] = SliceValue<INPUT_TYPE, INDEX_TYPE>(result, sliced, begin, end);
-		}
+INPUT_TYPE SliceValueWithSteps(Vector &result, SelectionVector &sel, INPUT_TYPE input, INDEX_TYPE begin, INDEX_TYPE end,
+                               INDEX_TYPE step, idx_t &sel_idx) {
+	return input;
+}
+
+template <>
+list_entry_t SliceValueWithSteps(Vector &result, SelectionVector &sel, list_entry_t input, int64_t begin, int64_t end,
+                                 int64_t step, idx_t &sel_idx) {
+	if (end - begin == 0) {
+		input.length = 0;
+		input.offset = sel_idx;
+		return input;
+	}
+	input.length = CalculateSliceLength(begin, end, step, true);
+	idx_t child_idx = input.offset + begin;
+	if (step < 0) {
+		child_idx = input.offset + end - 1;
+	}
+	input.offset = sel_idx;
+	for (idx_t i = 0; i < input.length; i++) {
+		sel.set_index(sel_idx, child_idx);
+		child_idx += step;
+		sel_idx++;
+	}
+	return input;
+}
+
+template <typename INPUT_TYPE, typename INDEX_TYPE>
+static void ExecuteConstantSlice(Vector &result, Vector &str_vector, Vector &begin_vector, Vector &end_vector,
+                                 optional_ptr<Vector> step_vector, const idx_t count, SelectionVector &sel,
+                                 idx_t &sel_idx, optional_ptr<Vector> result_child_vector, bool begin_is_empty,
+                                 bool end_is_empty) {
+	auto result_data = ConstantVector::GetData<INPUT_TYPE>(result);
+	auto str_data = ConstantVector::GetData<INPUT_TYPE>(str_vector);
+	auto begin_data = ConstantVector::GetData<INDEX_TYPE>(begin_vector);
+	auto end_data = ConstantVector::GetData<INDEX_TYPE>(end_vector);
+	auto step_data = step_vector ? ConstantVector::GetData<INDEX_TYPE>(*step_vector) : nullptr;
+
+	auto str = str_data[0];
+	auto begin = begin_is_empty ? 0 : begin_data[0];
+	auto end = end_is_empty ? ValueLength<INPUT_TYPE, INDEX_TYPE>(str) : end_data[0];
+	auto step = step_data ? step_data[0] : 1;
+
+	if (step < 0) {
+		swap(begin, end);
+		begin = end_is_empty ? 0 : begin;
+		end = begin_is_empty ? ValueLength<INPUT_TYPE, INDEX_TYPE>(str) : end;
+	}
+
+	auto str_valid = !ConstantVector::IsNull(str_vector);
+	auto begin_valid = !ConstantVector::IsNull(begin_vector);
+	auto end_valid = !ConstantVector::IsNull(end_vector);
+	auto step_valid = step_vector && !ConstantVector::IsNull(*step_vector);
+
+	// Clamp offsets
+	bool clamp_result = false;
+	if (str_valid && begin_valid && end_valid && (step_valid || step == 1)) {
+		clamp_result = ClampSlice(str, begin, end);
+	}
+
+	auto sel_length = 0;
+	if (step_vector && step_valid && str_valid && begin_valid && end_valid && step != 1 && end - begin > 0) {
+		sel_length = CalculateSliceLength(begin, end, step, step_valid);
+		sel.Initialize(sel_length);
+	}
+
+	// Try to slice
+	if (!str_valid || !begin_valid || !end_valid || (step_vector && !step_valid) || !clamp_result) {
+		ConstantVector::SetNull(result, true);
+	} else if (step == 1) {
+		result_data[0] = SliceValue<INPUT_TYPE, INDEX_TYPE>(result, str, begin, end);
 	} else {
-		UnifiedVectorFormat sdata, bdata, edata;
+		result_data[0] = SliceValueWithSteps<INPUT_TYPE, INDEX_TYPE>(result, sel, str, begin, end, step, sel_idx);
+	}
+
+	if (step_vector && step != 0 && end - begin > 0) {
+		result_child_vector->Slice(sel, sel_length);
+	}
+}
 
-		s.ToUnifiedFormat(count, sdata);
-		b.ToUnifiedFormat(count, bdata);
-		e.ToUnifiedFormat(count, edata);
+template <typename INPUT_TYPE, typename INDEX_TYPE>
+static void ExecuteFlatSlice(Vector &result, Vector &list_vector, Vector &begin_vector, Vector &end_vector,
+                             optional_ptr<Vector> step_vector, const idx_t count, SelectionVector &sel, idx_t &sel_idx,
+                             optional_ptr<Vector> result_child_vector, bool begin_is_empty, bool end_is_empty) {
+	UnifiedVectorFormat list_data, begin_data, end_data, step_data;
+	idx_t sel_length = 0;
 
-		auto rdata = FlatVector::GetData<INPUT_TYPE>(result);
-		auto &rmask = FlatVector::Validity(result);
+	list_vector.ToUnifiedFormat(count, list_data);
+	begin_vector.ToUnifiedFormat(count, begin_data);
+	end_vector.ToUnifiedFormat(count, end_data);
+	if (step_vector) {
+		step_vector->ToUnifiedFormat(count, step_data);
+		sel.Initialize(ListVector::GetListSize(list_vector));
+	}
 
-		for (idx_t i = 0; i < count; ++i) {
-			auto sidx = sdata.sel->get_index(i);
-			auto bidx = bdata.sel->get_index(i);
-			auto eidx = edata.sel->get_index(i);
+	auto result_data = FlatVector::GetData<INPUT_TYPE>(result);
+	auto &result_mask = FlatVector::Validity(result);
 
-			auto sliced = (UnifiedVectorFormat::GetData<INPUT_TYPE>(sdata))[sidx];
-			auto begin = (UnifiedVectorFormat::GetData<INDEX_TYPE>(bdata))[bidx];
-			auto end = (UnifiedVectorFormat::GetData<INDEX_TYPE>(edata))[eidx];
+	for (idx_t i = 0; i < count; ++i) {
+		auto list_idx = list_data.sel->get_index(i);
+		auto begin_idx = begin_data.sel->get_index(i);
+		auto end_idx = end_data.sel->get_index(i);
+		auto step_idx = step_vector ? step_data.sel->get_index(i) : 0;
 
-			auto svalid = sdata.validity.RowIsValid(sidx);
-			auto bvalid = bdata.validity.RowIsValid(bidx);
-			auto evalid = edata.validity.RowIsValid(eidx);
+		auto sliced = reinterpret_cast<INPUT_TYPE *>(list_data.data)[list_idx];
+		auto begin = begin_is_empty ? 0 : reinterpret_cast<INDEX_TYPE *>(begin_data.data)[begin_idx];
+		auto end = end_is_empty ? ValueLength<INPUT_TYPE, INDEX_TYPE>(sliced)
+		                        : reinterpret_cast<INDEX_TYPE *>(end_data.data)[end_idx];
+		auto step = step_vector ? reinterpret_cast<INDEX_TYPE *>(step_data.data)[step_idx] : 1;
 
-			// Try to slice
-			if (!svalid || !ClampSlice(sliced, begin, end, bvalid, evalid)) {
-				rmask.SetInvalid(i);
-			} else {
-				rdata[i] = SliceValue<INPUT_TYPE, INDEX_TYPE>(result, sliced, begin, end);
-			}
+		if (step < 0) {
+			swap(begin, end);
+			begin = end_is_empty ? 0 : begin;
+			end = begin_is_empty ? ValueLength<INPUT_TYPE, INDEX_TYPE>(sliced) : end;
+		}
+		auto list_valid = list_data.validity.RowIsValid(list_idx);
+		auto begin_valid = begin_data.validity.RowIsValid(begin_idx);
+		auto end_valid = end_data.validity.RowIsValid(end_idx);
+		auto step_valid = step_vector && step_data.validity.RowIsValid(step_idx);
+
+		bool clamp_result = false;
+		if (list_valid && begin_valid && end_valid && (step_valid || step == 1)) {
+			clamp_result = ClampSlice(sliced, begin, end);
+		}
+
+		auto length = 0;
+		if (step_vector && step_valid && list_valid && begin_valid && end_valid && end - begin > 0) {
+			length = CalculateSliceLength(begin, end, step, step_valid);
+		}
+		sel_length += length;
+
+		if (!list_valid || !begin_valid || !end_valid || (step_vector && !step_valid) || !clamp_result) {
+			result_mask.SetInvalid(i);
+		} else if (!step_vector) {
+			result_data[i] = SliceValue<INPUT_TYPE, INDEX_TYPE>(result, sliced, begin, end);
+		} else {
+			result_data[i] =
+			    SliceValueWithSteps<INPUT_TYPE, INDEX_TYPE>(result, sel, sliced, begin, end, step, sel_idx);
+		}
+	}
+	if (step_vector) {
+		SelectionVector new_sel(sel_length);
+		for (idx_t i = 0; i < sel_length; ++i) {
+			new_sel.set_index(i, sel.get_index(i));
 		}
+		result_child_vector->Slice(new_sel, sel_length);
 	}
+}
+
+template <typename INPUT_TYPE, typename INDEX_TYPE>
+static void ExecuteSlice(Vector &result, Vector &list_or_str_vector, Vector &begin_vector, Vector &end_vector,
+                         optional_ptr<Vector> step_vector, const idx_t count, bool begin_is_empty, bool end_is_empty) {
+	optional_ptr<Vector> result_child_vector;
+	if (step_vector) {
+		result_child_vector = &ListVector::GetEntry(result);
+	}
+
+	SelectionVector sel;
+	idx_t sel_idx = 0;
 
+	if (result.GetVectorType() == VectorType::CONSTANT_VECTOR) {
+		ExecuteConstantSlice<INPUT_TYPE, INDEX_TYPE>(result, list_or_str_vector, begin_vector, end_vector, step_vector,
+		                                             count, sel, sel_idx, result_child_vector, begin_is_empty,
+		                                             end_is_empty);
+	} else {
+		ExecuteFlatSlice<INPUT_TYPE, INDEX_TYPE>(result, list_or_str_vector, begin_vector, end_vector, step_vector,
+		                                         count, sel, sel_idx, result_child_vector, begin_is_empty,
+		                                         end_is_empty);
+	}
 	result.Verify(count);
 }
 
 static void ArraySliceFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 3);
-	D_ASSERT(args.data.size() == 3);
+	D_ASSERT(args.ColumnCount() == 3 || args.ColumnCount() == 4);
+	D_ASSERT(args.data.size() == 3 || args.data.size() == 4);
 	auto count = args.size();
 
-	Vector &s = args.data[0];
-	Vector &b = args.data[1];
-	Vector &e = args.data[2];
+	Vector &list_or_str_vector = args.data[0];
+	if (list_or_str_vector.GetType().id() == LogicalTypeId::SQLNULL) {
+		auto &result_validity = FlatVector::Validity(result);
+		result_validity.SetInvalid(0);
+		return;
+	}
+
+	Vector &begin_vector = args.data[1];
+	Vector &end_vector = args.data[2];
+
+	optional_ptr<Vector> step_vector;
+	if (args.ColumnCount() == 4) {
+		step_vector = &args.data[3];
+	}
+
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<ListSliceBindData>();
+	auto begin_is_empty = info.begin_is_empty;
+	auto end_is_empty = info.end_is_empty;
 
 	result.SetVectorType(args.AllConstant() ? VectorType::CONSTANT_VECTOR : VectorType::FLAT_VECTOR);
 	switch (result.GetType().id()) {
-	case LogicalTypeId::LIST:
+	case LogicalTypeId::LIST: {
 		// Share the value dictionary as we are just going to slice it
-		if (s.GetVectorType() != VectorType::FLAT_VECTOR && s.GetVectorType() != VectorType::CONSTANT_VECTOR) {
-			s.Flatten(count);
+		if (list_or_str_vector.GetVectorType() != VectorType::FLAT_VECTOR &&
+		    list_or_str_vector.GetVectorType() != VectorType::CONSTANT_VECTOR) {
+			list_or_str_vector.Flatten(count);
 		}
-		ListVector::ReferenceEntry(result, s);
-		ExecuteSlice<list_entry_t, int64_t>(result, s, b, e, count);
+		ListVector::ReferenceEntry(result, list_or_str_vector);
+		ExecuteSlice<list_entry_t, int64_t>(result, list_or_str_vector, begin_vector, end_vector, step_vector, count,
+		                                    begin_is_empty, end_is_empty);
 		break;
-	case LogicalTypeId::VARCHAR:
-		ExecuteSlice<string_t, int32_t>(result, s, b, e, count);
+	}
+	case LogicalTypeId::VARCHAR: {
+		ExecuteSlice<string_t, int64_t>(result, list_or_str_vector, begin_vector, end_vector, step_vector, count,
+		                                begin_is_empty, end_is_empty);
 		break;
+	}
 	default:
 		throw NotImplementedException("Specifier type not implemented");
 	}
 }
 
+static bool CheckIfParamIsEmpty(duckdb::unique_ptr<duckdb::Expression> &param) {
+	bool is_empty = false;
+	if (param->return_type.id() == LogicalTypeId::LIST) {
+		auto empty_list = make_uniq<BoundConstantExpression>(Value::LIST(LogicalType::INTEGER, vector<Value>()));
+		is_empty = param->Equals(*empty_list);
+		if (!is_empty) {
+			// if the param is not empty, the user has entered a list instead of a BIGINT
+			throw BinderException("The upper and lower bounds of the slice must be a BIGINT");
+		}
+	}
+	return is_empty;
+}
+
 static unique_ptr<FunctionData> ArraySliceBind(ClientContext &context, ScalarFunction &bound_function,
                                                vector<unique_ptr<Expression>> &arguments) {
-	D_ASSERT(bound_function.arguments.size() == 3);
+	D_ASSERT(arguments.size() == 3 || arguments.size() == 4);
+	D_ASSERT(bound_function.arguments.size() == 3 || bound_function.arguments.size() == 4);
+
 	switch (arguments[0]->return_type.id()) {
 	case LogicalTypeId::LIST:
 		// The result is the same type
 		bound_function.return_type = arguments[0]->return_type;
 		break;
 	case LogicalTypeId::VARCHAR:
-		// string slice returns a string, but can only accept 32 bit integers
+		// string slice returns a string
+		if (bound_function.arguments.size() == 4) {
+			throw NotImplementedException(
+			    "Slice with steps has not been implemented for string types, you can consider rewriting your query as "
+			    "follows:\n SELECT array_to_string((str_split(string, '')[begin:end:step], '');");
+		}
 		bound_function.return_type = arguments[0]->return_type;
-		bound_function.arguments[1] = LogicalType::INTEGER;
-		bound_function.arguments[2] = LogicalType::INTEGER;
+		for (idx_t i = 1; i < 3; i++) {
+			if (arguments[i]->return_type.id() != LogicalTypeId::LIST) {
+				bound_function.arguments[i] = LogicalType::BIGINT;
+			}
+		}
 		break;
 	case LogicalTypeId::SQLNULL:
 	case LogicalTypeId::UNKNOWN:
@@ -177,16 +396,29 @@ static unique_ptr<FunctionData> ArraySliceBind(ClientContext &context, ScalarFun
 		throw BinderException("ARRAY_SLICE can only operate on LISTs and VARCHARs");
 	}
 
-	return make_uniq<VariableReturnBindData>(bound_function.return_type);
+	bool begin_is_empty = CheckIfParamIsEmpty(arguments[1]);
+	if (!begin_is_empty) {
+		bound_function.arguments[1] = LogicalType::BIGINT;
+	}
+	bool end_is_empty = CheckIfParamIsEmpty(arguments[2]);
+	if (!end_is_empty) {
+		bound_function.arguments[2] = LogicalType::BIGINT;
+	}
+
+	return make_uniq<ListSliceBindData>(bound_function.return_type, begin_is_empty, end_is_empty);
 }
 
-ScalarFunction ListSliceFun::GetFunction() {
+ScalarFunctionSet ListSliceFun::GetFunctions() {
 	// the arguments and return types are actually set in the binder function
-	ScalarFunction fun({LogicalType::ANY, LogicalType::BIGINT, LogicalType::BIGINT}, LogicalType::ANY,
-	                   ArraySliceFunction, ArraySliceBind);
-	fun.varargs = LogicalType::ANY;
+	ScalarFunction fun({LogicalType::ANY, LogicalType::ANY, LogicalType::ANY}, LogicalType::ANY, ArraySliceFunction,
+	                   ArraySliceBind);
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return fun;
+
+	ScalarFunctionSet set;
+	set.AddFunction(fun);
+	fun.arguments.push_back(LogicalType::BIGINT);
+	set.AddFunction(fun);
+	return set;
 }
 
 } // namespace duckdb

package/src/duckdb/src/core_functions/scalar/list/list_aggregates.cpp

@@ -74,7 +74,8 @@ struct StateVector {
 		// destroy objects within the aggregate states
 		auto &aggr = aggr_expr->Cast<BoundAggregateExpression>();
 		if (aggr.function.destructor) {
-			AggregateInputData aggr_input_data(aggr.bind_info.get(), Allocator::DefaultAllocator());
+			ArenaAllocator allocator(Allocator::DefaultAllocator());
+			AggregateInputData aggr_input_data(aggr.bind_info.get(), allocator);
 			aggr.function.destructor(state_vector, aggr_input_data, count);
 		}
 	}
@@ -181,7 +182,8 @@ static void ListAggregatesFunction(DataChunk &args, ExpressionState &state, Vect
 	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	auto &info = func_expr.bind_info->Cast<ListAggregatesBindData>();
 	auto &aggr = info.aggr_expr->Cast<BoundAggregateExpression>();
-	AggregateInputData aggr_input_data(aggr.bind_info.get(), Allocator::DefaultAllocator());
+	ArenaAllocator allocator(Allocator::DefaultAllocator());
+	AggregateInputData aggr_input_data(aggr.bind_info.get(), allocator);
 
 	D_ASSERT(aggr.function.update);
 

package/src/duckdb/src/core_functions/scalar/list/list_lambdas.cpp

@@ -8,6 +8,8 @@
 #include "duckdb/planner/expression/bound_lambda_expression.hpp"
 #include "duckdb/planner/expression/bound_cast_expression.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -28,6 +30,19 @@ public:
 	                                            ScalarFunction &bound_function) {
 		throw NotImplementedException("FIXME: list lambda deserialize");
 	}
+
+	static void FormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+	                            const ScalarFunction &function) {
+		auto &bind_data = bind_data_p->Cast<ListLambdaBindData>();
+		serializer.WriteProperty(100, "stype", bind_data.stype);
+		serializer.WriteOptionalProperty(101, "lambda_expr", bind_data.lambda_expr);
+	}
+
+	static unique_ptr<FunctionData> FormatDeserialize(FormatDeserializer &deserializer, ScalarFunction &function) {
+		auto stype = deserializer.ReadProperty<LogicalType>(100, "stype");
+		auto lambda_expr = deserializer.ReadOptionalProperty<unique_ptr<Expression>>(101, "lambda_expr");
+		return make_uniq<ListLambdaBindData>(stype, std::move(lambda_expr));
+	}
 };
 
 ListLambdaBindData::ListLambdaBindData(const LogicalType &stype_p, unique_ptr<Expression> lambda_expr_p)
@@ -35,12 +50,12 @@ ListLambdaBindData::ListLambdaBindData(const LogicalType &stype_p, unique_ptr<Ex
 }
 
 unique_ptr<FunctionData> ListLambdaBindData::Copy() const {
-	return make_uniq<ListLambdaBindData>(stype, lambda_expr->Copy());
+	return make_uniq<ListLambdaBindData>(stype, lambda_expr ? lambda_expr->Copy() : nullptr);
 }
 
 bool ListLambdaBindData::Equals(const FunctionData &other_p) const {
 	auto &other = other_p.Cast<ListLambdaBindData>();
-	return lambda_expr->Equals(*other.lambda_expr) && stype == other.stype;
+	return Expression::Equals(lambda_expr, other.lambda_expr) && stype == other.stype;
 }
 
 ListLambdaBindData::~ListLambdaBindData() {
@@ -330,7 +345,7 @@ static unique_ptr<FunctionData> ListLambdaBind(ClientContext &context, ScalarFun
 	if (arguments[0]->return_type.id() == LogicalTypeId::SQLNULL) {
 		bound_function.arguments[0] = LogicalType::SQLNULL;
 		bound_function.return_type = LogicalType::SQLNULL;
-		return make_uniq<VariableReturnBindData>(bound_function.return_type);
+		return make_uniq<ListLambdaBindData>(bound_function.return_type, nullptr);
 	}
 
 	if (arguments[0]->return_type.id() == LogicalTypeId::UNKNOWN) {
@@ -385,6 +400,8 @@ ScalarFunction ListTransformFun::GetFunction() {
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	fun.serialize = ListLambdaBindData::Serialize;
 	fun.deserialize = ListLambdaBindData::Deserialize;
+	fun.format_serialize = ListLambdaBindData::FormatSerialize;
+	fun.format_deserialize = ListLambdaBindData::FormatDeserialize;
 	return fun;
 }
 
@@ -394,6 +411,8 @@ ScalarFunction ListFilterFun::GetFunction() {
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	fun.serialize = ListLambdaBindData::Serialize;
 	fun.deserialize = ListLambdaBindData::Deserialize;
+	fun.format_serialize = ListLambdaBindData::FormatSerialize;
+	fun.format_deserialize = ListLambdaBindData::FormatDeserialize;
 	return fun;
 }
 

package/src/duckdb/src/core_functions/scalar/map/map_entries.cpp

@@ -42,8 +42,8 @@ static unique_ptr<FunctionData> MapEntriesBind(ClientContext &context, ScalarFun
 	auto &key_type = MapType::KeyType(map);
 	auto &value_type = MapType::ValueType(map);
 
-	child_types.push_back(make_pair("k", key_type));
-	child_types.push_back(make_pair("v", value_type));
+	child_types.push_back(make_pair("key", key_type));
+	child_types.push_back(make_pair("value", value_type));
 
 	auto row_type = LogicalType::STRUCT(child_types);
 

package/src/duckdb/src/core_functions/scalar/string/to_base.cpp

@@ -0,0 +1,66 @@
+#include "duckdb/core_functions/scalar/string_functions.hpp"
+#include "duckdb/common/vector_operations/vector_operations.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
+
+namespace duckdb {
+
+static const char alphabet[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+static unique_ptr<FunctionData> ToBaseBind(ClientContext &context, ScalarFunction &bound_function,
+                                           vector<unique_ptr<Expression>> &arguments) {
+	// If no min_length is specified, default to 0
+	D_ASSERT(arguments.size() == 2 || arguments.size() == 3);
+	if (arguments.size() == 2) {
+		arguments.push_back(make_uniq_base<Expression, BoundConstantExpression>(Value::INTEGER(0)));
+	}
+	return nullptr;
+}
+
+static void ToBaseFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &input = args.data[0];
+	auto &radix = args.data[1];
+	auto &min_length = args.data[2];
+	auto count = args.size();
+
+	TernaryExecutor::Execute<int64_t, int32_t, int32_t, string_t>(
+	    input, radix, min_length, result, count, [&](int64_t input, int32_t radix, int32_t min_length) {
+		    if (input < 0) {
+			    throw InvalidInputException("'to_base' number must be greater than or equal to 0");
+		    }
+		    if (radix < 2 || radix > 36) {
+			    throw InvalidInputException("'to_base' radix must be between 2 and 36");
+		    }
+		    if (min_length > 64 || min_length < 0) {
+			    throw InvalidInputException("'to_base' min_length must be between 0 and 64");
+		    }
+
+		    char buf[64];
+		    char *end = buf + sizeof(buf);
+		    char *ptr = end;
+		    do {
+			    *--ptr = alphabet[input % radix];
+			    input /= radix;
+		    } while (input > 0);
+
+		    auto length = end - ptr;
+		    while (length < min_length) {
+			    *--ptr = '0';
+			    length++;
+		    }
+
+		    return StringVector::AddString(result, ptr, end - ptr);
+	    });
+}
+
+ScalarFunctionSet ToBaseFun::GetFunctions() {
+	ScalarFunctionSet set("to_base");
+
+	set.AddFunction(
+	    ScalarFunction({LogicalType::BIGINT, LogicalType::INTEGER}, LogicalType::VARCHAR, ToBaseFunction, ToBaseBind));
+	set.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::INTEGER, LogicalType::INTEGER},
+	                               LogicalType::VARCHAR, ToBaseFunction, ToBaseBind));
+
+	return set;
+}
+
+} // namespace duckdb

package/src/duckdb/src/core_functions/scalar/union/union_tag.cpp

@@ -39,7 +39,7 @@ static unique_ptr<FunctionData> UnionTagBind(ClientContext &context, ScalarFunct
 		FlatVector::GetData<string_t>(varchar_vector)[i] =
 		    str.IsInlined() ? str : StringVector::AddString(varchar_vector, str);
 	}
-	auto enum_type = LogicalType::ENUM("", varchar_vector, member_count);
+	auto enum_type = LogicalType::ENUM(varchar_vector, member_count);
 	bound_function.return_type = enum_type;
 
 	return nullptr;