duckdb 1.0.1-dev22.0 → 1.0.1-dev27.0

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

@@ -1,83 +1,69 @@
 #include "duckdb/function/scalar/nested_functions.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/common/operator/comparison_operators.hpp"
 #include "duckdb/planner/expression/bound_cast_expression.hpp"
+#include "duckdb/planner/expression_binder.hpp"
+#include "duckdb/function/scalar/list/contains_or_position.hpp"
 
 namespace duckdb {
 
-static void ListContainsFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	(void)state;
-	return ListContainsOrPosition<bool, ContainsFunctor, ListArgFunctor>(args, result);
-}
+template <bool RETURN_POSITION>
+static void ListSearchFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+	auto target_count = input.size();
+	auto &list_vec = input.data[0];
+	auto &source_vec = ListVector::GetEntry(list_vec);
+	auto &target_vec = input.data[1];
 
-static void ListPositionFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	(void)state;
-	return ListContainsOrPosition<int32_t, PositionFunctor, ListArgFunctor>(args, result);
+	ListSearchOp<RETURN_POSITION>(list_vec, source_vec, target_vec, result, target_count);
+
+	if (target_count == 1) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
 }
 
-template <LogicalTypeId RETURN_TYPE>
-static unique_ptr<FunctionData> ListContainsOrPositionBind(ClientContext &context, ScalarFunction &bound_function,
-                                                           vector<unique_ptr<Expression>> &arguments) {
+static unique_ptr<FunctionData> ListSearchBind(ClientContext &context, ScalarFunction &bound_function,
+                                               vector<unique_ptr<Expression>> &arguments) {
 	D_ASSERT(bound_function.arguments.size() == 2);
 
 	// If the first argument is an array, cast it to a list
 	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
 
-	const auto &list = arguments[0]->return_type; // change to list
+	const auto &list = arguments[0]->return_type;
 	const auto &value = arguments[1]->return_type;
-	if (list.id() == LogicalTypeId::UNKNOWN) {
-		bound_function.return_type = RETURN_TYPE;
-		if (value.id() != LogicalTypeId::UNKNOWN) {
+
+	const auto list_is_param = list.id() == LogicalTypeId::UNKNOWN;
+	const auto value_is_param = value.id() == LogicalTypeId::UNKNOWN;
+
+	if (list_is_param) {
+		if (!value_is_param) {
 			// only list is a parameter, cast it to a list of value type
 			bound_function.arguments[0] = LogicalType::LIST(value);
 			bound_function.arguments[1] = value;
 		}
-	} else if (value.id() == LogicalTypeId::UNKNOWN) {
+	} else if (value_is_param) {
 		// only value is a parameter: we expect the child type of list
-		auto const &child_type = ListType::GetChildType(list);
 		bound_function.arguments[0] = list;
-		bound_function.arguments[1] = child_type;
-		bound_function.return_type = RETURN_TYPE;
+		bound_function.arguments[1] = ListType::GetChildType(list);
 	} else {
-		auto const &child_type = ListType::GetChildType(list);
 		LogicalType max_child_type;
-		if (!LogicalType::TryGetMaxLogicalType(context, child_type, value, max_child_type)) {
+		if (!LogicalType::TryGetMaxLogicalType(context, ListType::GetChildType(list), value, max_child_type)) {
 			throw BinderException(
-			    "Cannot get list_position of element of type %s in a list of type %s[] - an explicit cast is required",
-			    value.ToString(), child_type.ToString());
+			    "%s: Cannot match element of type '%s' in a list of type '%s' - an explicit cast is required",
+			    bound_function.name, value.ToString(), list.ToString());
 		}
-		auto list_type = LogicalType::LIST(max_child_type);
-
-		bound_function.arguments[0] = list_type;
-		bound_function.arguments[1] = value == max_child_type ? value : max_child_type;
 
-		// list_contains and list_position only differ in their return type
-		bound_function.return_type = RETURN_TYPE;
+		bound_function.arguments[0] = LogicalType::LIST(max_child_type);
+		bound_function.arguments[1] = max_child_type;
 	}
 	return make_uniq<VariableReturnBindData>(bound_function.return_type);
 }
 
-static unique_ptr<FunctionData> ListContainsBind(ClientContext &context, ScalarFunction &bound_function,
-                                                 vector<unique_ptr<Expression>> &arguments) {
-	return ListContainsOrPositionBind<LogicalType::BOOLEAN>(context, bound_function, arguments);
-}
-
-static unique_ptr<FunctionData> ListPositionBind(ClientContext &context, ScalarFunction &bound_function,
-                                                 vector<unique_ptr<Expression>> &arguments) {
-	return ListContainsOrPositionBind<LogicalType::INTEGER>(context, bound_function, arguments);
-}
-
 ScalarFunction ListContainsFun::GetFunction() {
-	return ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::ANY}, // argument list
-	                      LogicalType::BOOLEAN,                                    // return type
-	                      ListContainsFunction, ListContainsBind, nullptr);
+	return ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::ANY}, LogicalType::BOOLEAN,
+	                      ListSearchFunction<false>, ListSearchBind);
 }
 
 ScalarFunction ListPositionFun::GetFunction() {
-	return ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::ANY}, // argument list
-	                      LogicalType::INTEGER,                                    // return type
-	                      ListPositionFunction, ListPositionBind, nullptr);
+	return ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::ANY}, LogicalType::INTEGER,
+	                      ListSearchFunction<true>, ListSearchBind);
 }
 
 void ListContainsFun::RegisterFunction(BuiltinFunctions &set) {

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

@@ -1,171 +1,105 @@
 #include "duckdb/common/pair.hpp"
 #include "duckdb/common/string_util.hpp"
-
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/common/uhugeint.hpp"
 #include "duckdb/common/vector_operations/binary_executor.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_cast_expression.hpp"
+#include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/storage/statistics/list_stats.hpp"
 
 namespace duckdb {
 
-template <class T, bool HEAP_REF = false, bool VALIDITY_ONLY = false>
-void ListExtractTemplate(idx_t count, UnifiedVectorFormat &list_data, UnifiedVectorFormat &offsets_data,
-                         Vector &child_vector, idx_t list_size, Vector &result) {
-	UnifiedVectorFormat child_format;
-	child_vector.ToUnifiedFormat(list_size, child_format);
-
-	T *result_data;
+static optional_idx TryGetChildOffset(const list_entry_t &list_entry, const int64_t offset) {
+	// 1-based indexing
+	if (offset == 0) {
+		return optional_idx::Invalid();
+	}
 
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	if (!VALIDITY_ONLY) {
-		result_data = FlatVector::GetData<T>(result);
+	const auto index_offset = (offset > 0) ? offset - 1 : offset;
+	if (index_offset < 0) {
+		const auto signed_list_length = UnsafeNumericCast<int64_t>(list_entry.length);
+		if (signed_list_length + index_offset < 0) {
+			return optional_idx::Invalid();
+		}
+		return optional_idx(list_entry.offset + UnsafeNumericCast<idx_t>(signed_list_length + index_offset));
 	}
-	auto &result_mask = FlatVector::Validity(result);
 
-	// heap-ref once
-	if (HEAP_REF) {
-		StringVector::AddHeapReference(result, child_vector);
+	const auto unsigned_offset = UnsafeNumericCast<idx_t>(index_offset);
+
+	// Check that the offset is within the list
+	if (unsigned_offset >= list_entry.length) {
+		return optional_idx::Invalid();
 	}
 
-	// this is lifted from ExecuteGenericLoop because we can't push the list child data into this otherwise
-	// should have gone with GetValue perhaps
-	auto child_data = UnifiedVectorFormat::GetData<T>(child_format);
+	return optional_idx(list_entry.offset + unsigned_offset);
+}
+
+static void ExecuteListExtract(Vector &result, Vector &list, Vector &offsets, const idx_t count) {
+	D_ASSERT(list.GetType().id() == LogicalTypeId::LIST);
+	UnifiedVectorFormat list_data;
+	UnifiedVectorFormat offsets_data;
+
+	list.ToUnifiedFormat(count, list_data);
+	offsets.ToUnifiedFormat(count, offsets_data);
+
+	const auto list_ptr = UnifiedVectorFormat::GetData<list_entry_t>(list_data);
+	const auto offsets_ptr = UnifiedVectorFormat::GetData<int64_t>(offsets_data);
+
+	UnifiedVectorFormat child_data;
+	auto &child_vector = ListVector::GetEntry(list);
+	auto child_count = ListVector::GetListSize(list);
+	child_vector.ToUnifiedFormat(child_count, child_data);
+
+	SelectionVector sel(count);
+	vector<idx_t> invalid_offsets;
+
+	optional_idx first_valid_child_idx;
 	for (idx_t i = 0; i < count; i++) {
-		auto list_index = list_data.sel->get_index(i);
-		auto offsets_index = offsets_data.sel->get_index(i);
-		if (!list_data.validity.RowIsValid(list_index)) {
-			result_mask.SetInvalid(i);
-			continue;
-		}
-		if (!offsets_data.validity.RowIsValid(offsets_index)) {
-			result_mask.SetInvalid(i);
+		const auto list_index = list_data.sel->get_index(i);
+		const auto offsets_index = offsets_data.sel->get_index(i);
+
+		if (!list_data.validity.RowIsValid(list_index) || !offsets_data.validity.RowIsValid(offsets_index)) {
+			invalid_offsets.push_back(i);
 			continue;
 		}
-		auto list_entry = (UnifiedVectorFormat::GetData<list_entry_t>(list_data))[list_index];
-		auto offsets_entry = (UnifiedVectorFormat::GetData<int64_t>(offsets_data))[offsets_index];
 
-		// 1-based indexing
-		if (offsets_entry == 0) {
-			result_mask.SetInvalid(i);
+		const auto child_offset = TryGetChildOffset(list_ptr[list_index], offsets_ptr[offsets_index]);
+
+		if (!child_offset.IsValid()) {
+			invalid_offsets.push_back(i);
 			continue;
 		}
-		offsets_entry = (offsets_entry > 0) ? offsets_entry - 1 : offsets_entry;
-
-		idx_t child_offset;
-		if (offsets_entry < 0) {
-			if (offsets_entry < -int64_t(list_entry.length)) {
-				result_mask.SetInvalid(i);
-				continue;
-			}
-			child_offset = UnsafeNumericCast<idx_t>(UnsafeNumericCast<int64_t>(list_entry.offset + list_entry.length) +
-			                                        offsets_entry);
-		} else {
-			if ((idx_t)offsets_entry >= list_entry.length) {
-				result_mask.SetInvalid(i);
-				continue;
-			}
-			child_offset = UnsafeNumericCast<idx_t>(UnsafeNumericCast<int64_t>(list_entry.offset) + offsets_entry);
-		}
-		auto child_index = child_format.sel->get_index(child_offset);
-		if (child_format.validity.RowIsValid(child_index)) {
-			if (!VALIDITY_ONLY) {
-				result_data[i] = child_data[child_index];
-			}
-		} else {
-			result_mask.SetInvalid(i);
+
+		const auto child_idx = child_data.sel->get_index(child_offset.GetIndex());
+		sel.set_index(i, child_idx);
+
+		if (!first_valid_child_idx.IsValid()) {
+			// Save the first valid child as a dummy index to copy in VectorOperations::Copy later
+			first_valid_child_idx = child_idx;
 		}
 	}
-	if (count == 1) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-static void ExecuteListExtractInternal(const idx_t count, UnifiedVectorFormat &list, UnifiedVectorFormat &offsets,
-                                       Vector &child_vector, idx_t list_size, Vector &result) {
-	D_ASSERT(child_vector.GetType() == result.GetType());
-	switch (result.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		ListExtractTemplate<int8_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case PhysicalType::INT16:
-		ListExtractTemplate<int16_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case PhysicalType::INT32:
-		ListExtractTemplate<int32_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case PhysicalType::INT64:
-		ListExtractTemplate<int64_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case PhysicalType::INT128:
-		ListExtractTemplate<hugeint_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case PhysicalType::UINT8:
-		ListExtractTemplate<uint8_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case PhysicalType::UINT16:
-		ListExtractTemplate<uint16_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case PhysicalType::UINT32:
-		ListExtractTemplate<uint32_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case PhysicalType::UINT64:
-		ListExtractTemplate<uint64_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case PhysicalType::UINT128:
-		ListExtractTemplate<uhugeint_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case PhysicalType::FLOAT:
-		ListExtractTemplate<float>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case PhysicalType::DOUBLE:
-		ListExtractTemplate<double>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case PhysicalType::VARCHAR:
-		ListExtractTemplate<string_t, true>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case PhysicalType::INTERVAL:
-		ListExtractTemplate<interval_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	case PhysicalType::STRUCT: {
-		auto &entries = StructVector::GetEntries(child_vector);
-		auto &result_entries = StructVector::GetEntries(result);
-		D_ASSERT(entries.size() == result_entries.size());
-		// extract the child entries of the struct
-		for (idx_t i = 0; i < entries.size(); i++) {
-			ExecuteListExtractInternal(count, list, offsets, *entries[i], list_size, *result_entries[i]);
+
+	if (first_valid_child_idx.IsValid()) {
+		// Only copy if we found at least one valid child
+		for (const auto &invalid_offset : invalid_offsets) {
+			sel.set_index(invalid_offset, first_valid_child_idx.GetIndex());
 		}
-		// extract the validity mask
-		ListExtractTemplate<bool, false, true>(count, list, offsets, child_vector, list_size, result);
-		break;
+		VectorOperations::Copy(child_vector, result, sel, count, 0, 0);
 	}
-	case PhysicalType::LIST: {
-		// nested list: we have to reference the child
-		auto &child_child_list = ListVector::GetEntry(child_vector);
 
-		ListVector::GetEntry(result).Reference(child_child_list);
-		ListVector::SetListSize(result, ListVector::GetListSize(child_vector));
-		ListExtractTemplate<list_entry_t>(count, list, offsets, child_vector, list_size, result);
-		break;
-	}
-	default:
-		throw NotImplementedException("Unimplemented type for LIST_EXTRACT");
+	// Copy:ing the vectors also copies the validity mask, so we set the rows with invalid offsets (0) to false here.
+	for (const auto &invalid_idx : invalid_offsets) {
+		FlatVector::SetNull(result, invalid_idx, true);
 	}
-}
 
-static void ExecuteListExtract(Vector &result, Vector &list, Vector &offsets, const idx_t count) {
-	D_ASSERT(list.GetType().id() == LogicalTypeId::LIST);
-	UnifiedVectorFormat list_data;
-	UnifiedVectorFormat offsets_data;
+	if (count == 1 || (list.GetVectorType() == VectorType::CONSTANT_VECTOR &&
+	                   offsets.GetVectorType() == VectorType::CONSTANT_VECTOR)) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
 
-	list.ToUnifiedFormat(count, list_data);
-	offsets.ToUnifiedFormat(count, offsets_data);
-	ExecuteListExtractInternal(count, list_data, offsets_data, ListVector::GetEntry(list),
-	                           ListVector::GetListSize(list), result);
 	result.Verify(count);
 }
 
@@ -180,13 +114,6 @@ static void ListExtractFunction(DataChunk &args, ExpressionState &state, Vector
 	D_ASSERT(args.ColumnCount() == 2);
 	auto count = args.size();
 
-	result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	for (idx_t i = 0; i < args.ColumnCount(); i++) {
-		if (args.data[i].GetVectorType() != VectorType::CONSTANT_VECTOR) {
-			result.SetVectorType(VectorType::FLAT_VECTOR);
-		}
-	}
-
 	Vector &base = args.data[0];
 	Vector &subscript = args.data[1];
 

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

@@ -6,105 +6,114 @@
 
 namespace duckdb {
 
-void ListResizeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.data[1].GetType().id() == LogicalTypeId::UBIGINT);
+void ListResizeFunction(DataChunk &args, ExpressionState &, Vector &result) {
+
+	// Early-out, if the return value is a constant NULL.
 	if (result.GetType().id() == LogicalTypeId::SQLNULL) {
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
 		ConstantVector::SetNull(result, 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];
+	auto row_count = args.size();
 
-	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<uint64_t>(new_size_data);
+	UnifiedVectorFormat lists_data;
+	lists.ToUnifiedFormat(row_count, lists_data);
+	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
+	auto list_entries = UnifiedVectorFormat::GetData<list_entry_t>(lists_data);
 
+	auto &child_vector = ListVector::GetEntry(lists);
 	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];
+	child_vector.ToUnifiedFormat(row_count, child_data);
+
+	UnifiedVectorFormat new_sizes_data;
+	new_sizes.ToUnifiedFormat(row_count, new_sizes_data);
+	D_ASSERT(new_sizes.GetType().id() == LogicalTypeId::UBIGINT);
+	auto new_size_entries = UnifiedVectorFormat::GetData<uint64_t>(new_sizes_data);
+
+	// Get the new size of the result child vector.
+	// We skip rows with NULL values in the input lists.
+	idx_t child_vector_size = 0;
+	for (idx_t row_idx = 0; row_idx < row_count; row_idx++) {
+		auto list_idx = lists_data.sel->get_index(row_idx);
+		auto new_size_idx = new_sizes_data.sel->get_index(row_idx);
+
+		if (lists_data.validity.RowIsValid(list_idx) && new_sizes_data.validity.RowIsValid(new_size_idx)) {
+			child_vector_size += new_size_entries[new_size_idx];
 		}
 	}
+	ListVector::Reserve(result, child_vector_size);
+	ListVector::SetListSize(result, child_vector_size);
+
+	result.SetVectorType(VectorType::FLAT_VECTOR);
+	auto result_entries = FlatVector::GetData<list_entry_t>(result);
+	auto &result_validity = FlatVector::Validity(result);
+	auto &result_child_vector = ListVector::GetEntry(result);
 
-	// Create the default vector if it exists
+	// Get the default values, if provided.
 	UnifiedVectorFormat default_data;
 	optional_ptr<Vector> default_vector;
 	if (args.ColumnCount() == 3) {
 		default_vector = &args.data[2];
-		default_vector->Flatten(count);
-		default_vector->ToUnifiedFormat(count, default_data);
-		default_vector->SetVectorType(VectorType::CONSTANT_VECTOR);
+		default_vector->ToUnifiedFormat(row_count, default_data);
 	}
 
-	ListVector::Reserve(result, new_child_size);
-	ListVector::SetListSize(result, new_child_size);
+	idx_t offset = 0;
+	for (idx_t row_idx = 0; row_idx < row_count; row_idx++) {
 
-	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);
+		auto list_idx = lists_data.sel->get_index(row_idx);
+		auto new_size_idx = new_sizes_data.sel->get_index(row_idx);
 
-		// set null if lists is null
-		if (!list_data.validity.RowIsValid(l_index)) {
-			FlatVector::SetNull(result, args_index, true);
+		// Set to NULL, if the list is NULL.
+		if (!lists_data.validity.RowIsValid(list_idx)) {
+			result_validity.SetInvalid(row_idx);
 			continue;
 		}
 
-		idx_t new_size_entry = 0;
-		if (new_size_data.validity.RowIsValid(new_index)) {
-			new_size_entry = new_size_entries[new_index];
+		idx_t new_size = 0;
+		if (new_sizes_data.validity.RowIsValid(new_size_idx)) {
+			new_size = new_size_entries[new_size_idx];
 		}
 
-		// 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 new_size >= length, then we copy [0, length) values.
+		// If new_size < length, then we copy [0, new_size) values.
+		auto copy_count = MinValue<idx_t>(list_entries[list_idx].length, new_size);
+
+		// Set the result entry.
+		result_entries[row_idx].offset = offset;
+		result_entries[row_idx].length = new_size;
+
+		// Copy the child vector's values.
+		// The number of elements to copy is later determined like so: source_count - source_offset.
+		idx_t source_offset = list_entries[list_idx].offset;
+		idx_t source_count = source_offset + copy_count;
+		VectorOperations::Copy(child_vector, result_child_vector, source_count, source_offset, offset);
+		offset += copy_count;
+
+		// Fill the remaining space with the default values.
+		if (copy_count < new_size) {
+			idx_t remaining_count = new_size - copy_count;
+
+			if (default_vector) {
+				auto default_idx = default_data.sel->get_index(row_idx);
+				if (default_data.validity.RowIsValid(default_idx)) {
+					SelectionVector sel(remaining_count);
+					for (idx_t j = 0; j < remaining_count; j++) {
+						sel.set_index(j, row_idx);
+					}
+					VectorOperations::Copy(*default_vector, result_child_vector, sel, remaining_count, 0, offset);
+					offset += remaining_count;
+					continue;
 				}
 			}
+
+			// Fill the remaining space with NULL.
+			for (idx_t j = copy_count; j < new_size; j++) {
+				FlatVector::SetNull(result_child_vector, offset, true);
+				offset++;
+			}
 		}
 	}
 
@@ -118,23 +127,23 @@ static unique_ptr<FunctionData> ListResizeBind(ClientContext &context, ScalarFun
 	D_ASSERT(bound_function.arguments.size() == 2 || arguments.size() == 3);
 	bound_function.arguments[1] = LogicalType::UBIGINT;
 
-	// If the first argument is an array, cast it to a list
+	// If the first argument is an array, cast it to a list.
 	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
 
-	// first argument is constant NULL
+	// Early-out, if the first argument is a 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
+	// Early-out, if the first argument is a prepared statement.
 	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
+	// Attempt implicit casting, if the default type does not match list the list child type.
 	if (bound_function.arguments.size() == 3 &&
 	    ListType::GetChildType(arguments[0]->return_type) != arguments[2]->return_type &&
 	    arguments[2]->return_type != LogicalTypeId::SQLNULL) {
@@ -146,22 +155,22 @@ static unique_ptr<FunctionData> ListResizeBind(ClientContext &context, ScalarFun
 }
 
 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 simple_fun({LogicalType::LIST(LogicalTypeId::ANY), LogicalTypeId::ANY},
+	                          LogicalType::LIST(LogicalTypeId::ANY), ListResizeFunction, ListResizeBind);
+	simple_fun.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;
+	ScalarFunction default_value_fun({LogicalType::LIST(LogicalTypeId::ANY), LogicalTypeId::ANY, LogicalTypeId::ANY},
+	                                 LogicalType::LIST(LogicalTypeId::ANY), ListResizeFunction, ListResizeBind);
+	default_value_fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 
 	ScalarFunctionSet list_resize("list_resize");
-	list_resize.AddFunction(sfun);
-	list_resize.AddFunction(dfun);
+	list_resize.AddFunction(simple_fun);
+	list_resize.AddFunction(default_value_fun);
 	set.AddFunction(list_resize);
 
 	ScalarFunctionSet array_resize("array_resize");
-	array_resize.AddFunction(sfun);
-	array_resize.AddFunction(dfun);
+	array_resize.AddFunction(simple_fun);
+	array_resize.AddFunction(default_value_fun);
 	set.AddFunction(array_resize);
 }
 

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

@@ -1,5 +1,6 @@
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
 #include "duckdb/planner/expression_binder.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
@@ -138,6 +139,8 @@ static unique_ptr<FunctionData> ListZipBind(ClientContext &context, ScalarFuncti
 		auto &child = arguments[i];
 		switch (child->return_type.id()) {
 		case LogicalTypeId::LIST:
+		case LogicalTypeId::ARRAY:
+			child = BoundCastExpression::AddArrayCastToList(context, std::move(child));
 			struct_children.push_back(make_pair(string(), ListType::GetChildType(child->return_type)));
 			break;
 		case LogicalTypeId::SQLNULL: