duckdb 1.3.4 → 1.4.0

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

@@ -6,7 +6,8 @@
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "duckdb/main/config.hpp"
-#include "duckdb/common/sort/sort.hpp"
+#include "duckdb/common/sorting/sort.hpp"
+#include "duckdb/parallel/thread_context.hpp"
 
 namespace duckdb {
 
@@ -22,11 +23,9 @@ struct ListSortBindData : public FunctionData {
 	bool is_grade_up;
 
 	vector<LogicalType> types;
-	vector<LogicalType> payload_types;
 
 	ClientContext &context;
-	RowLayout payload_layout;
-	vector<BoundOrderByNode> orders;
+	unique_ptr<Sort> sort;
 
 public:
 	bool Equals(const FunctionData &other_p) const override;
@@ -42,20 +41,17 @@ ListSortBindData::ListSortBindData(OrderType order_type_p, OrderByNullType null_
 	// get the vector types
 	types.emplace_back(LogicalType::USMALLINT);
 	types.emplace_back(child_type);
-	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);
+	types.emplace_back(LogicalType::UINTEGER);
+	D_ASSERT(types.size() == 3);
 
 	// 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 {
@@ -71,32 +67,26 @@ ListSortBindData::~ListSortBindData() {
 }
 
 // create the key_chunk and the payload_chunk and sink them into the local_sort_state
-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) {
+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) {
 
 	// slice the child vector
 	Vector slice(*child_vector, sel, offset_lists_indices);
 
-	// 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();
+	// 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();
 
 	// sink
-	key_chunk.Flatten();
-	local_sort_state.SinkChunk(key_chunk, payload_chunk);
+	chunk.Flatten();
+	sort.Sink(context, chunk, sink_input);
 	data_to_sort = true;
 }
 
@@ -117,10 +107,12 @@ 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 &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);
+	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};
 
 	Vector sort_result_vec = info.is_grade_up ? Vector(input_lists.GetType()) : result;
 
@@ -174,8 +166,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(&child_vector, sel, offset_lists_indices, info.types, info.payload_types, payload_vector,
-				              local_sort_state, data_to_sort, lists_indices);
+				SinkDataChunk(*info.sort, execution_context, sink_input, &child_vector, sel, offset_lists_indices,
+				              info.types, payload_vector, data_to_sort, lists_indices);
 				offset_lists_indices = 0;
 			}
 
@@ -189,8 +181,8 @@ static void ListSortFunction(DataChunk &args, ExpressionState &state, Vector &re
 	}
 
 	if (offset_lists_indices != 0) {
-		SinkDataChunk(&child_vector, sel, offset_lists_indices, info.types, info.payload_types, payload_vector,
-		              local_sort_state, data_to_sort, lists_indices);
+		SinkDataChunk(*info.sort, execution_context, sink_input, &child_vector, sel, offset_lists_indices, info.types,
+		              payload_vector, data_to_sort, lists_indices);
 	}
 
 	if (info.is_grade_up) {
@@ -202,20 +194,25 @@ static void ListSortFunction(DataChunk &args, ExpressionState &state, Vector &re
 
 	if (data_to_sort) {
 		// add local state to global state, which sorts the data
-		global_sort_state.AddLocalState(local_sort_state);
-		global_sort_state.PrepareMergePhase();
+		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);
 
 		// 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
-		PayloadScanner scanner(*global_sort_state.sorted_blocks[0]->payload_data, global_sort_state);
+		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};
 		for (;;) {
 			DataChunk result_chunk;
-			result_chunk.Initialize(Allocator::DefaultAllocator(), info.payload_types);
+			result_chunk.Initialize(Allocator::DefaultAllocator(), {LogicalType::UINTEGER});
 			result_chunk.SetCardinality(0);
-			scanner.Scan(result_chunk);
+			info.sort->GetData(execution_context, result_chunk, source_input);
 			if (result_chunk.size() == 0) {
 				break;
 			}
@@ -303,8 +300,8 @@ static unique_ptr<FunctionData> ListGradeUpBind(ClientContext &context, ScalarFu
 		null_order = GetOrder<OrderByNullType>(context, *arguments[2]);
 	}
 	auto &config = DBConfig::GetConfig(context);
-	order = config.ResolveOrder(order);
-	null_order = config.ResolveNullOrder(order, null_order);
+	order = config.ResolveOrder(context, order);
+	null_order = config.ResolveNullOrder(context, order, null_order);
 
 	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
 
@@ -329,8 +326,8 @@ static unique_ptr<FunctionData> ListNormalSortBind(ClientContext &context, Scala
 		null_order = GetOrder<OrderByNullType>(context, *arguments[2]);
 	}
 	auto &config = DBConfig::GetConfig(context);
-	order = config.ResolveOrder(order);
-	null_order = config.ResolveNullOrder(order, null_order);
+	order = config.ResolveOrder(context, order);
+	null_order = config.ResolveNullOrder(context, order, null_order);
 	return ListSortBind(context, bound_function, arguments, order, null_order);
 }
 
@@ -343,7 +340,7 @@ static unique_ptr<FunctionData> ListReverseSortBind(ClientContext &context, Scal
 		null_order = GetOrder<OrderByNullType>(context, *arguments[1]);
 	}
 	auto &config = DBConfig::GetConfig(context);
-	order = config.ResolveOrder(order);
+	order = config.ResolveOrder(context, order);
 	switch (order) {
 	case OrderType::ASCENDING:
 		order = OrderType::DESCENDING;
@@ -354,7 +351,7 @@ static unique_ptr<FunctionData> ListReverseSortBind(ClientContext &context, Scal
 	default:
 		throw InternalException("Unexpected order type in list reverse sort");
 	}
-	null_order = config.ResolveNullOrder(order, null_order);
+	null_order = config.ResolveNullOrder(context, order, null_order);
 	return ListSortBind(context, bound_function, arguments, order, null_order);
 }
 

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

@@ -4,108 +4,58 @@
 #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 {
 
-struct ListValueAssign {
+namespace {
+
+struct PrimitiveAssign {
 	template <class T>
 	static T Assign(const T &input, Vector &result) {
 		return input;
 	}
 };
 
-struct ListValueStringAssign {
+struct StringAssign {
 	template <class T>
 	static T Assign(const T &input, Vector &result) {
 		return StringVector::AddStringOrBlob(result, input);
 	}
 };
 
-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 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);
-			}
-		}
-		result_data[r].offset = r * list_size;
-		result_data[r].length = list_size;
-	}
-	ListVector::SetListSize(result, args.size() * list_size);
-}
+template <class T, class OP = PrimitiveAssign>
+void TemplatedPopulateChild(DataChunk &args, Vector &result) {
+	const auto column_count = args.ColumnCount();
+	const auto row_count = args.size();
 
-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;
-	}
+	D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
+	auto result_data = FlatVector::GetData<T>(result);
+	auto result_validity = &FlatVector::Validity(result);
 
-	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);
+	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;
 			}
+			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);
-	ListVector::SetListSize(result_list, offset_sum);
 }
 
-static void TemplatedListValueFunctionFallback(DataChunk &args, Vector &result) {
+void PopulateChildFallback(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++) {
@@ -118,107 +68,223 @@ static void TemplatedListValueFunctionFallback(DataChunk &args, Vector &result)
 	}
 }
 
-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()) {
+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()) {
 	case PhysicalType::BOOL:
 	case PhysicalType::INT8:
-		TemplatedListValueFunction<int8_t>(args, result);
+		TemplatedPopulateChild<int8_t>(args, result);
 		break;
 	case PhysicalType::INT16:
-		TemplatedListValueFunction<int16_t>(args, result);
+		TemplatedPopulateChild<int16_t>(args, result);
 		break;
 	case PhysicalType::INT32:
-		TemplatedListValueFunction<int32_t>(args, result);
+		TemplatedPopulateChild<int32_t>(args, result);
 		break;
 	case PhysicalType::INT64:
-		TemplatedListValueFunction<int64_t>(args, result);
+		TemplatedPopulateChild<int64_t>(args, result);
 		break;
 	case PhysicalType::UINT8:
-		TemplatedListValueFunction<uint8_t>(args, result);
+		TemplatedPopulateChild<uint8_t>(args, result);
 		break;
 	case PhysicalType::UINT16:
-		TemplatedListValueFunction<uint16_t>(args, result);
+		TemplatedPopulateChild<uint16_t>(args, result);
 		break;
 	case PhysicalType::UINT32:
-		TemplatedListValueFunction<uint32_t>(args, result);
+		TemplatedPopulateChild<uint32_t>(args, result);
 		break;
 	case PhysicalType::UINT64:
-		TemplatedListValueFunction<uint64_t>(args, result);
+		TemplatedPopulateChild<uint64_t>(args, result);
 		break;
 	case PhysicalType::INT128:
-		TemplatedListValueFunction<hugeint_t>(args, result);
+		TemplatedPopulateChild<hugeint_t>(args, result);
 		break;
 	case PhysicalType::UINT128:
-		TemplatedListValueFunction<uhugeint_t>(args, result);
+		TemplatedPopulateChild<uhugeint_t>(args, result);
 		break;
 	case PhysicalType::FLOAT:
-		TemplatedListValueFunction<float>(args, result);
+		TemplatedPopulateChild<float>(args, result);
 		break;
 	case PhysicalType::DOUBLE:
-		TemplatedListValueFunction<double>(args, result);
+		TemplatedPopulateChild<double>(args, result);
 		break;
 	case PhysicalType::INTERVAL:
-		TemplatedListValueFunction<interval_t>(args, result);
+		TemplatedPopulateChild<interval_t>(args, result);
 		break;
 	case PhysicalType::VARCHAR:
-		TemplatedListValueFunction<string_t, ListValueStringAssign>(args, result);
+		TemplatedPopulateChild<string_t, StringAssign>(args, result);
 		break;
 	case PhysicalType::LIST:
-		ListValueListFunction(args, result);
-		break;
-	default: {
-		TemplatedListValueFunctionFallback(args, result);
+		ListFunction(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);
 }
 
-template <bool IS_UNPIVOT = false>
-static unique_ptr<FunctionData> ListValueBind(ClientContext &context, ScalarFunction &bound_function,
-                                              vector<unique_ptr<Expression>> &arguments) {
+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) {
 	// 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)) {
-			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();
+			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();
 				}
-				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());
+				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));
 		}
 	}
 	child_type = LogicalType::NormalizeType(child_type);
@@ -240,19 +306,33 @@ unique_ptr<BaseStatistics> ListValueStats(ClientContext &context, FunctionStatis
 	return list_stats.ToUnique();
 }
 
-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;
+} // 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 UnpivotListFun::GetFunction() {
-	auto fun = ListValueFun::GetFunction();
-	fun.name = "unpivot_list";
-	fun.bind = ListValueBind<true>;
+	ScalarFunction fun("unpivot_list", {}, LogicalTypeId::LIST, ListValueFunction, UnpivotBind, nullptr,
+	                   ListValueStats);
+	fun.varargs = LogicalTypeId::ANY;
+	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	return fun;
 }