duckdb 1.3.3-dev4.0 → 1.3.3

package/src/duckdb/extension/core_functions/scalar/list/list_sort.cpp

@@ -6,8 +6,7 @@
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "duckdb/main/config.hpp"
-#include "duckdb/common/sorting/sort.hpp"
-#include "duckdb/parallel/thread_context.hpp"
+#include "duckdb/common/sort/sort.hpp"
 
 namespace duckdb {
 
@@ -23,9 +22,11 @@ struct ListSortBindData : public FunctionData {
 	bool is_grade_up;
 
 	vector<LogicalType> types;
+	vector<LogicalType> payload_types;
 
 	ClientContext &context;
-	unique_ptr<Sort> sort;
+	RowLayout payload_layout;
+	vector<BoundOrderByNode> orders;
 
 public:
 	bool Equals(const FunctionData &other_p) const override;
@@ -41,17 +42,20 @@ ListSortBindData::ListSortBindData(OrderType order_type_p, OrderByNullType null_
 	// get the vector types
 	types.emplace_back(LogicalType::USMALLINT);
 	types.emplace_back(child_type);
-	types.emplace_back(LogicalType::UINTEGER);
-	D_ASSERT(types.size() == 3);
+	D_ASSERT(types.size() == 2);
+
+	// get the payload types
+	payload_types.emplace_back(LogicalType::UINTEGER);
+	D_ASSERT(payload_types.size() == 1);
+
+	// initialize the payload layout
+	payload_layout.Initialize(payload_types);
 
 	// get the BoundOrderByNode
 	auto idx_col_expr = make_uniq_base<Expression, BoundReferenceExpression>(LogicalType::USMALLINT, 0U);
 	auto lists_col_expr = make_uniq_base<Expression, BoundReferenceExpression>(child_type, 1U);
-	vector<BoundOrderByNode> orders;
 	orders.emplace_back(OrderType::ASCENDING, OrderByNullType::ORDER_DEFAULT, std::move(idx_col_expr));
 	orders.emplace_back(order_type, null_order, std::move(lists_col_expr));
-	sort =
-	    unique_ptr<Sort>(new Sort(context, orders, {LogicalType::USMALLINT, child_type, LogicalType::UINTEGER}, {2}));
 }
 
 unique_ptr<FunctionData> ListSortBindData::Copy() const {
@@ -67,26 +71,32 @@ ListSortBindData::~ListSortBindData() {
 }
 
 // create the key_chunk and the payload_chunk and sink them into the local_sort_state
-static void SinkDataChunk(const Sort &sort, ExecutionContext &context, OperatorSinkInput &sink_input,
-                          Vector *child_vector, SelectionVector &sel, idx_t offset_lists_indices,
-                          vector<LogicalType> &types, Vector &payload_vector, bool &data_to_sort,
-                          Vector &lists_indices) {
+void SinkDataChunk(Vector *child_vector, SelectionVector &sel, idx_t offset_lists_indices, vector<LogicalType> &types,
+                   vector<LogicalType> &payload_types, Vector &payload_vector, LocalSortState &local_sort_state,
+                   bool &data_to_sort, Vector &lists_indices) {
 
 	// slice the child vector
 	Vector slice(*child_vector, sel, offset_lists_indices);
 
-	// initialize and fill chunk
-	DataChunk chunk;
-	chunk.InitializeEmpty(types);
-	chunk.data[0].Reference(lists_indices);
-	chunk.data[1].Reference(slice);
-	chunk.data[2].Reference(payload_vector);
-	chunk.SetCardinality(offset_lists_indices);
-	chunk.Verify();
+	// initialize and fill key_chunk
+	DataChunk key_chunk;
+	key_chunk.InitializeEmpty(types);
+	key_chunk.data[0].Reference(lists_indices);
+	key_chunk.data[1].Reference(slice);
+	key_chunk.SetCardinality(offset_lists_indices);
+
+	// initialize and fill key_chunk and payload_chunk
+	DataChunk payload_chunk;
+	payload_chunk.InitializeEmpty(payload_types);
+	payload_chunk.data[0].Reference(payload_vector);
+	payload_chunk.SetCardinality(offset_lists_indices);
+
+	key_chunk.Verify();
+	payload_chunk.Verify();
 
 	// sink
-	chunk.Flatten();
-	sort.Sink(context, chunk, sink_input);
+	key_chunk.Flatten();
+	local_sort_state.SinkChunk(key_chunk, payload_chunk);
 	data_to_sort = true;
 }
 
@@ -107,12 +117,10 @@ static void ListSortFunction(DataChunk &args, ExpressionState &state, Vector &re
 	auto &info = func_expr.bind_info->Cast<ListSortBindData>();
 
 	// initialize the global and local sorting state
-	auto global_sink_state = info.sort->GetGlobalSinkState(info.context);
-	ThreadContext thread_context(info.context);
-	ExecutionContext execution_context(info.context, thread_context, nullptr);
-	auto local_sink_state = info.sort->GetLocalSinkState(execution_context);
-	InterruptState interrupt_state;
-	OperatorSinkInput sink_input {*global_sink_state, *local_sink_state, interrupt_state};
+	auto &buffer_manager = BufferManager::GetBufferManager(info.context);
+	GlobalSortState global_sort_state(info.context, info.orders, info.payload_layout);
+	LocalSortState local_sort_state;
+	local_sort_state.Initialize(global_sort_state, buffer_manager);
 
 	Vector sort_result_vec = info.is_grade_up ? Vector(input_lists.GetType()) : result;
 
@@ -166,8 +174,8 @@ static void ListSortFunction(DataChunk &args, ExpressionState &state, Vector &re
 		for (idx_t child_idx = 0; child_idx < list_entry.length; child_idx++) {
 			// lists_indices vector is full, sink
 			if (offset_lists_indices == STANDARD_VECTOR_SIZE) {
-				SinkDataChunk(*info.sort, execution_context, sink_input, &child_vector, sel, offset_lists_indices,
-				              info.types, payload_vector, data_to_sort, lists_indices);
+				SinkDataChunk(&child_vector, sel, offset_lists_indices, info.types, info.payload_types, payload_vector,
+				              local_sort_state, data_to_sort, lists_indices);
 				offset_lists_indices = 0;
 			}
 
@@ -181,8 +189,8 @@ static void ListSortFunction(DataChunk &args, ExpressionState &state, Vector &re
 	}
 
 	if (offset_lists_indices != 0) {
-		SinkDataChunk(*info.sort, execution_context, sink_input, &child_vector, sel, offset_lists_indices, info.types,
-		              payload_vector, data_to_sort, lists_indices);
+		SinkDataChunk(&child_vector, sel, offset_lists_indices, info.types, info.payload_types, payload_vector,
+		              local_sort_state, data_to_sort, lists_indices);
 	}
 
 	if (info.is_grade_up) {
@@ -194,25 +202,20 @@ static void ListSortFunction(DataChunk &args, ExpressionState &state, Vector &re
 
 	if (data_to_sort) {
 		// add local state to global state, which sorts the data
-		OperatorSinkCombineInput combine_input {*global_sink_state, *local_sink_state, interrupt_state};
-		info.sort->Combine(execution_context, combine_input);
-
-		OperatorSinkFinalizeInput finalize_input {*global_sink_state, interrupt_state};
-		info.sort->Finalize(info.context, finalize_input);
+		global_sort_state.AddLocalState(local_sort_state);
+		global_sort_state.PrepareMergePhase();
 
 		// selection vector that is to be filled with the 'sorted' payload
 		SelectionVector sel_sorted(incr_payload_count);
 		idx_t sel_sorted_idx = 0;
 
 		// scan the sorted row data
-		auto global_source_state = info.sort->GetGlobalSourceState(info.context, *global_sink_state);
-		auto local_source_state = info.sort->GetLocalSourceState(execution_context, *global_source_state);
-		OperatorSourceInput source_input {*global_source_state, *local_source_state, interrupt_state};
+		PayloadScanner scanner(*global_sort_state.sorted_blocks[0]->payload_data, global_sort_state);
 		for (;;) {
 			DataChunk result_chunk;
-			result_chunk.Initialize(Allocator::DefaultAllocator(), {LogicalType::UINTEGER});
+			result_chunk.Initialize(Allocator::DefaultAllocator(), info.payload_types);
 			result_chunk.SetCardinality(0);
-			info.sort->GetData(execution_context, result_chunk, source_input);
+			scanner.Scan(result_chunk);
 			if (result_chunk.size() == 0) {
 				break;
 			}
@@ -300,8 +303,8 @@ static unique_ptr<FunctionData> ListGradeUpBind(ClientContext &context, ScalarFu
 		null_order = GetOrder<OrderByNullType>(context, *arguments[2]);
 	}
 	auto &config = DBConfig::GetConfig(context);
-	order = config.ResolveOrder(context, order);
-	null_order = config.ResolveNullOrder(context, order, null_order);
+	order = config.ResolveOrder(order);
+	null_order = config.ResolveNullOrder(order, null_order);
 
 	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
 
@@ -326,8 +329,8 @@ static unique_ptr<FunctionData> ListNormalSortBind(ClientContext &context, Scala
 		null_order = GetOrder<OrderByNullType>(context, *arguments[2]);
 	}
 	auto &config = DBConfig::GetConfig(context);
-	order = config.ResolveOrder(context, order);
-	null_order = config.ResolveNullOrder(context, order, null_order);
+	order = config.ResolveOrder(order);
+	null_order = config.ResolveNullOrder(order, null_order);
 	return ListSortBind(context, bound_function, arguments, order, null_order);
 }
 
@@ -340,7 +343,7 @@ static unique_ptr<FunctionData> ListReverseSortBind(ClientContext &context, Scal
 		null_order = GetOrder<OrderByNullType>(context, *arguments[1]);
 	}
 	auto &config = DBConfig::GetConfig(context);
-	order = config.ResolveOrder(context, order);
+	order = config.ResolveOrder(order);
 	switch (order) {
 	case OrderType::ASCENDING:
 		order = OrderType::DESCENDING;
@@ -351,7 +354,7 @@ static unique_ptr<FunctionData> ListReverseSortBind(ClientContext &context, Scal
 	default:
 		throw InternalException("Unexpected order type in list reverse sort");
 	}
-	null_order = config.ResolveNullOrder(context, order, null_order);
+	null_order = config.ResolveNullOrder(order, null_order);
 	return ListSortBind(context, bound_function, arguments, order, null_order);
 }
 

package/src/duckdb/extension/core_functions/scalar/list/list_value.cpp

@@ -4,58 +4,108 @@
 #include "duckdb/parser/expression/bound_expression.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/common/pair.hpp"
-#include "duckdb/function/cast/vector_cast_helpers.hpp"
 #include "duckdb/storage/statistics/list_stats.hpp"
 #include "duckdb/planner/expression_binder.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/parser/query_error_context.hpp"
-#include "duckdb/parser/tableref/at_clause.hpp"
-#include "duckdb/planner/expression/bound_case_expression.hpp"
 
 namespace duckdb {
 
-namespace {
-
-struct PrimitiveAssign {
+struct ListValueAssign {
 	template <class T>
 	static T Assign(const T &input, Vector &result) {
 		return input;
 	}
 };
 
-struct StringAssign {
+struct ListValueStringAssign {
 	template <class T>
 	static T Assign(const T &input, Vector &result) {
 		return StringVector::AddStringOrBlob(result, input);
 	}
 };
 
-template <class T, class OP = PrimitiveAssign>
-void TemplatedPopulateChild(DataChunk &args, Vector &result) {
-	const auto column_count = args.ColumnCount();
-	const auto row_count = args.size();
-
-	D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
-	auto result_data = FlatVector::GetData<T>(result);
-	auto result_validity = &FlatVector::Validity(result);
+template <class T, class OP = ListValueAssign>
+static void TemplatedListValueFunction(DataChunk &args, Vector &result) {
+	idx_t list_size = args.ColumnCount();
+	ListVector::Reserve(result, args.size() * list_size);
+	auto result_data = FlatVector::GetData<list_entry_t>(result);
+	auto &list_child = ListVector::GetEntry(result);
+	auto child_data = FlatVector::GetData<T>(list_child);
+	auto &child_validity = FlatVector::Validity(list_child);
 
 	auto unified_format = args.ToUnifiedFormat();
-	for (idx_t row = 0; row < row_count; row++) {
-		for (idx_t col = 0; col < column_count; col++) {
-			auto input_idx = unified_format[col].sel->get_index(row);
-			auto result_idx = row * column_count + col;
-			if (!unified_format[col].validity.RowIsValid(input_idx)) {
-				result_validity->SetInvalid(result_idx);
-				continue;
+	for (idx_t r = 0; r < args.size(); r++) {
+		for (idx_t c = 0; c < list_size; c++) {
+			auto input_idx = unified_format[c].sel->get_index(r);
+			auto result_idx = r * list_size + c;
+			auto input_data = UnifiedVectorFormat::GetData<T>(unified_format[c]);
+			if (unified_format[c].validity.RowIsValid(input_idx)) {
+				child_data[result_idx] = OP::template Assign<T>(input_data[input_idx], list_child);
+			} else {
+				child_validity.SetInvalid(result_idx);
 			}
-			const auto input_data = UnifiedVectorFormat::GetData<T>(unified_format[col]);
-			auto val = OP::template Assign<T>(input_data[input_idx], result);
-			result_data[result_idx] = val;
 		}
+		result_data[r].offset = r * list_size;
+		result_data[r].length = list_size;
 	}
+	ListVector::SetListSize(result, args.size() * list_size);
 }
 
-void PopulateChildFallback(DataChunk &args, Vector &result) {
+static void ListValueListFunction(DataChunk &args, Vector &result) {
+	const idx_t list_size = args.ColumnCount();
+	ListVector::Reserve(result, args.size() * list_size);
+
+	vector<idx_t> col_offsets;
+	idx_t offset_sum = 0;
+	for (idx_t i = 0; i < list_size; i++) {
+		col_offsets.push_back(offset_sum);
+		auto &list = args.data[i];
+		const auto length = ListVector::GetListSize(list);
+		offset_sum += length;
+	}
+
+	auto &result_list = ListVector::GetEntry(result);
+	ListVector::Reserve(result_list, offset_sum);
+
+	auto &result_child_vector = ListVector::GetEntry(result_list);
+	for (idx_t i = 0; i < list_size; i++) {
+		auto list = args.data[i];
+		const auto length = ListVector::GetListSize(list);
+		if (length == 0) {
+			continue;
+		}
+		auto &child_vector = ListVector::GetEntry(list);
+		VectorOperations::Copy(child_vector, result_child_vector, length, 0, col_offsets[i]);
+	}
+
+	const auto result_data = FlatVector::GetData<list_entry_t>(result);
+	const auto result_list_data = FlatVector::GetData<list_entry_t>(result_list);
+	auto &result_list_validity = FlatVector::Validity(result_list);
+
+	const auto args_unified_format = args.ToUnifiedFormat();
+	for (idx_t r = 0; r < args.size(); r++) {
+		for (idx_t c = 0; c < list_size; c++) {
+			const auto input_idx = args_unified_format[c].sel->get_index(r);
+			const auto result_idx = r * list_size + c;
+			const auto input_data = UnifiedVectorFormat::GetData<list_entry_t>(args_unified_format[c]);
+			if (args_unified_format[c].validity.RowIsValid(input_idx)) {
+				const auto length = input_data[input_idx].length;
+				const auto offset = col_offsets[c] + input_data[input_idx].offset;
+				result_list_data[result_idx] = list_entry_t(offset, length);
+			} else {
+				result_list_validity.SetInvalid(result_idx);
+			}
+		}
+		result_data[r].offset = r * list_size;
+		result_data[r].length = list_size;
+	}
+
+	ListVector::SetListSize(result, args.size() * list_size);
+	ListVector::SetListSize(result_list, offset_sum);
+}
+
+static void TemplatedListValueFunctionFallback(DataChunk &args, Vector &result) {
 	auto &child_type = ListType::GetChildType(result.GetType());
 	auto result_data = FlatVector::GetData<list_entry_t>(result);
 	for (idx_t i = 0; i < args.size(); i++) {
@@ -68,223 +118,107 @@ void PopulateChildFallback(DataChunk &args, Vector &result) {
 	}
 }
 
-void ListFunction(DataChunk &args, Vector &result);
-bool StructFunction(DataChunk &args, Vector &result);
-
-template <class OP = PrimitiveAssign>
-bool PopulateChild(DataChunk &args, Vector &result) {
-	switch (result.GetType().InternalType()) {
+static void ListValueFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
+	result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	if (args.ColumnCount() == 0) {
+		// no columns - early out - result is a constant empty list
+		auto result_data = FlatVector::GetData<list_entry_t>(result);
+		result_data[0].length = 0;
+		result_data[0].offset = 0;
+		return;
+	}
+	for (idx_t i = 0; i < args.ColumnCount(); i++) {
+		if (args.data[i].GetVectorType() != VectorType::CONSTANT_VECTOR) {
+			result.SetVectorType(VectorType::FLAT_VECTOR);
+		}
+	}
+	auto &result_type = ListVector::GetEntry(result).GetType();
+	switch (result_type.InternalType()) {
 	case PhysicalType::BOOL:
 	case PhysicalType::INT8:
-		TemplatedPopulateChild<int8_t>(args, result);
+		TemplatedListValueFunction<int8_t>(args, result);
 		break;
 	case PhysicalType::INT16:
-		TemplatedPopulateChild<int16_t>(args, result);
+		TemplatedListValueFunction<int16_t>(args, result);
 		break;
 	case PhysicalType::INT32:
-		TemplatedPopulateChild<int32_t>(args, result);
+		TemplatedListValueFunction<int32_t>(args, result);
 		break;
 	case PhysicalType::INT64:
-		TemplatedPopulateChild<int64_t>(args, result);
+		TemplatedListValueFunction<int64_t>(args, result);
 		break;
 	case PhysicalType::UINT8:
-		TemplatedPopulateChild<uint8_t>(args, result);
+		TemplatedListValueFunction<uint8_t>(args, result);
 		break;
 	case PhysicalType::UINT16:
-		TemplatedPopulateChild<uint16_t>(args, result);
+		TemplatedListValueFunction<uint16_t>(args, result);
 		break;
 	case PhysicalType::UINT32:
-		TemplatedPopulateChild<uint32_t>(args, result);
+		TemplatedListValueFunction<uint32_t>(args, result);
 		break;
 	case PhysicalType::UINT64:
-		TemplatedPopulateChild<uint64_t>(args, result);
+		TemplatedListValueFunction<uint64_t>(args, result);
 		break;
 	case PhysicalType::INT128:
-		TemplatedPopulateChild<hugeint_t>(args, result);
+		TemplatedListValueFunction<hugeint_t>(args, result);
 		break;
 	case PhysicalType::UINT128:
-		TemplatedPopulateChild<uhugeint_t>(args, result);
+		TemplatedListValueFunction<uhugeint_t>(args, result);
 		break;
 	case PhysicalType::FLOAT:
-		TemplatedPopulateChild<float>(args, result);
+		TemplatedListValueFunction<float>(args, result);
 		break;
 	case PhysicalType::DOUBLE:
-		TemplatedPopulateChild<double>(args, result);
+		TemplatedListValueFunction<double>(args, result);
 		break;
 	case PhysicalType::INTERVAL:
-		TemplatedPopulateChild<interval_t>(args, result);
+		TemplatedListValueFunction<interval_t>(args, result);
 		break;
 	case PhysicalType::VARCHAR:
-		TemplatedPopulateChild<string_t, StringAssign>(args, result);
+		TemplatedListValueFunction<string_t, ListValueStringAssign>(args, result);
 		break;
 	case PhysicalType::LIST:
-		ListFunction(args, result);
+		ListValueListFunction(args, result);
+		break;
+	default: {
+		TemplatedListValueFunctionFallback(args, result);
 		break;
-	case PhysicalType::STRUCT:
-		return StructFunction(args, result);
-	case PhysicalType::UNKNOWN:
-	case PhysicalType::INVALID:
-		throw InternalException("Cannot create a list of types %s - an explicit cast is required",
-		                        result.GetType().ToString());
-	default:
-		// execute the fallback instead, which requires the parent result
-		return false;
-	}
-	return true;
-}
-
-void ListFunction(DataChunk &args, Vector &result) {
-	const idx_t column_count = args.ColumnCount();
-
-	vector<idx_t> col_offsets;
-	idx_t offset_sum = 0;
-	for (idx_t col = 0; col < column_count; col++) {
-		col_offsets.push_back(offset_sum);
-		auto &list = args.data[col];
-		const auto length = ListVector::GetListSize(list);
-		offset_sum += length;
-	}
-
-	ListVector::Reserve(result, offset_sum);
-
-	// The result vector is [[a], [b], ...], result_child is [a, b, ...].
-	auto &result_child = ListVector::GetEntry(result);
-
-	auto unified_format = args.ToUnifiedFormat();
-	vector<const list_entry_t *> col_data;
-	for (idx_t col = 0; col < column_count; col++) {
-		auto list = args.data[col];
-		col_data.push_back(UnifiedVectorFormat::GetData<list_entry_t>(unified_format[col]));
-
-		const auto length = ListVector::GetListSize(list);
-		if (length == 0) {
-			continue;
-		}
-		auto &child_vector = ListVector::GetEntry(list);
-		VectorOperations::Copy(child_vector, result_child, length, 0, col_offsets[col]);
-	}
-
-	D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
-	auto result_data = FlatVector::GetData<list_entry_t>(result);
-	auto result_validity = &FlatVector::Validity(result);
-
-	for (idx_t row = 0; row < args.size(); row++) {
-		for (idx_t col = 0; col < column_count; col++) {
-			const auto input_idx = unified_format[col].sel->get_index(row);
-			const auto result_idx = row * column_count + col;
-			if (!unified_format[col].validity.RowIsValid(input_idx)) {
-				result_validity->SetInvalid(result_idx);
-				continue;
-			}
-			const auto input = col_data[col][input_idx];
-			const auto length = input.length;
-			const auto offset = col_offsets[col] + input.offset;
-			result_data[result_idx] = list_entry_t(offset, length);
-		}
-	}
-	ListVector::SetListSize(result, offset_sum);
-}
-
-bool StructFunction(DataChunk &args, Vector &result) {
-	const idx_t column_count = args.ColumnCount();
-	auto &result_members = StructVector::GetEntries(result);
-
-	for (idx_t member_idx = 0; member_idx < result_members.size(); member_idx++) {
-		// Same type for each column's member.
-		vector<LogicalType> types;
-		const auto member_type = result_members[member_idx]->GetType();
-		for (idx_t col = 0; col < column_count; col++) {
-			types.push_back(member_type);
-		}
-
-		DataChunk chunk;
-		chunk.InitializeEmpty(types);
-		chunk.SetCardinality(args.size());
-
-		for (idx_t col = 0; col < column_count; col++) {
-			const auto &struct_vector = args.data[col];
-			auto &struct_vector_members = StructVector::GetEntries(struct_vector);
-			chunk.data[col].Reference(*struct_vector_members[member_idx]);
-		}
-
-		if (!PopulateChild(chunk, *result_members[member_idx])) {
-			return false;
-		}
-	}
-
-	// Set the top level result validity
-	const auto unified_format = args.ToUnifiedFormat();
-	auto &result_validity = FlatVector::Validity(result);
-	for (idx_t row = 0; row < args.size(); row++) {
-		for (idx_t col = 0; col < column_count; col++) {
-			const auto input_idx = unified_format[col].sel->get_index(row);
-			const auto result_idx = row * column_count + col;
-			if (!unified_format[col].validity.RowIsValid(input_idx)) {
-				result_validity.SetInvalid(result_idx);
-			}
-		}
-	}
-
-	return true;
-}
-
-void ListValueFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
-
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	if (args.ColumnCount() == 0) {
-		// Early out because the result is a constant empty list.
-		auto result_data = FlatVector::GetData<list_entry_t>(result);
-		result_data[0].length = 0;
-		result_data[0].offset = 0;
-		return;
-	}
-
-	for (idx_t i = 0; i < args.ColumnCount(); i++) {
-		if (args.data[i].GetVectorType() != VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-		}
-	}
-
-	ListVector::Reserve(result, args.size() * args.ColumnCount());
-	auto &result_child = ListVector::GetEntry(result);
-
-	if (!PopulateChild(args, result_child)) {
-		PopulateChildFallback(args, result);
 	}
-
-	const idx_t column_count = args.ColumnCount();
-	auto result_data = FlatVector::GetData<list_entry_t>(result);
-	for (idx_t row = 0; row < args.size(); row++) {
-		result_data[row].offset = row * column_count;
-		result_data[row].length = column_count;
 	}
-	ListVector::SetListSize(result, column_count * args.size());
 }
 
-unique_ptr<FunctionData> UnpivotBind(ClientContext &context, ScalarFunction &bound_function,
-                                     vector<unique_ptr<Expression>> &arguments) {
+template <bool IS_UNPIVOT = false>
+static unique_ptr<FunctionData> ListValueBind(ClientContext &context, ScalarFunction &bound_function,
+                                              vector<unique_ptr<Expression>> &arguments) {
 	// collect names and deconflict, construct return type
 	LogicalType child_type =
 	    arguments.empty() ? LogicalType::SQLNULL : ExpressionBinder::GetExpressionReturnType(*arguments[0]);
 	for (idx_t i = 1; i < arguments.size(); i++) {
 		auto arg_type = ExpressionBinder::GetExpressionReturnType(*arguments[i]);
 		if (!LogicalType::TryGetMaxLogicalType(context, child_type, arg_type, child_type)) {
-			string list_arguments = "Full list: ";
-			idx_t error_index = list_arguments.size();
-			for (idx_t k = 0; k < arguments.size(); k++) {
-				if (k > 0) {
-					list_arguments += ", ";
-				}
-				if (k == i) {
-					error_index = list_arguments.size();
+			if (IS_UNPIVOT) {
+				string list_arguments = "Full list: ";
+				idx_t error_index = list_arguments.size();
+				for (idx_t k = 0; k < arguments.size(); k++) {
+					if (k > 0) {
+						list_arguments += ", ";
+					}
+					if (k == i) {
+						error_index = list_arguments.size();
+					}
+					list_arguments += arguments[k]->ToString() + " " + arguments[k]->return_type.ToString();
 				}
-				list_arguments += arguments[k]->ToString() + " " + arguments[k]->return_type.ToString();
+				auto error =
+				    StringUtil::Format("Cannot unpivot columns of types %s and %s - an explicit cast is required",
+				                       child_type.ToString(), arg_type.ToString());
+				throw BinderException(arguments[i]->GetQueryLocation(),
+				                      QueryErrorContext::Format(list_arguments, error, error_index, false));
+			} else {
+				throw BinderException(arguments[i]->GetQueryLocation(),
+				                      "Cannot create a list of types %s and %s - an explicit cast is required",
+				                      child_type.ToString(), arg_type.ToString());
 			}
-			auto error = StringUtil::Format("Cannot unpivot columns of types %s and %s - an explicit cast is required",
-			                                child_type.ToString(), arg_type.ToString());
-			throw BinderException(arguments[i]->GetQueryLocation(),
-			                      QueryErrorContext::Format(list_arguments, error, error_index, false));
 		}
 	}
 	child_type = LogicalType::NormalizeType(child_type);
@@ -306,33 +240,19 @@ unique_ptr<BaseStatistics> ListValueStats(ClientContext &context, FunctionStatis
 	return list_stats.ToUnique();
 }
 
-} // namespace
-
-ScalarFunctionSet ListValueFun::GetFunctions() {
-
-	ScalarFunctionSet set("list_value");
-
-	// Overload for 0 arguments, which returns an empty list.
-	ScalarFunction empty_fun({}, LogicalType::LIST(LogicalType::SQLNULL), ListValueFunction, nullptr, nullptr,
-	                         ListValueStats);
-	set.AddFunction(empty_fun);
-
-	// Overload for 1 + N arguments, which returns a list of the arguments.
-	auto element_type = LogicalType::TEMPLATE("T");
-	ScalarFunction value_fun({element_type}, LogicalType::LIST(element_type), ListValueFunction, nullptr, nullptr,
-	                         ListValueStats);
-	value_fun.varargs = element_type;
-	value_fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	set.AddFunction(value_fun);
-
-	return set;
+ScalarFunction ListValueFun::GetFunction() {
+	// the arguments and return types are actually set in the binder function
+	ScalarFunction fun("list_value", {}, LogicalTypeId::LIST, ListValueFunction, ListValueBind, nullptr,
+	                   ListValueStats);
+	fun.varargs = LogicalType::ANY;
+	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+	return fun;
 }
 
 ScalarFunction UnpivotListFun::GetFunction() {
-	ScalarFunction fun("unpivot_list", {}, LogicalTypeId::LIST, ListValueFunction, UnpivotBind, nullptr,
-	                   ListValueStats);
-	fun.varargs = LogicalTypeId::ANY;
-	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+	auto fun = ListValueFun::GetFunction();
+	fun.name = "unpivot_list";
+	fun.bind = ListValueBind<true>;
 	return fun;
 }