duckdb 0.10.2 → 0.10.3-dev10.0

package/src/duckdb/src/execution/window_executor.cpp

@@ -139,11 +139,11 @@ struct WindowColumnIterator {
 
 	//	Random Access
 	inline iterator &operator+=(difference_type n) {
-		pos += n;
+		pos += UnsafeNumericCast<pointer>(n);
 		return *this;
 	}
 	inline iterator &operator-=(difference_type n) {
-		pos -= n;
+		pos -= UnsafeNumericCast<pointer>(n);
 		return *this;
 	}
 
@@ -232,7 +232,7 @@ static idx_t FindTypedRangeBound(const WindowInputColumn &over, const idx_t orde
 			const auto first = over.GetCell<T>(prev.start);
 			if (!comp(val, first)) {
 				//	prev.first <= val, so we can start further forward
-				begin += (prev.start - order_begin);
+				begin += UnsafeNumericCast<int64_t>(prev.start - order_begin);
 			}
 		}
 		if (order_begin < prev.end && prev.end < order_end) {
@@ -240,7 +240,7 @@ static idx_t FindTypedRangeBound(const WindowInputColumn &over, const idx_t orde
 			if (!comp(second, val)) {
 				//	val <= prev.second, so we can end further back
 				// (prev.second is the largest peer)
-				end -= (order_end - prev.end - 1);
+				end -= UnsafeNumericCast<int64_t>(order_end - prev.end - 1);
 			}
 		}
 	}
@@ -452,13 +452,13 @@ void WindowBoundariesState::Update(const idx_t row_idx, const WindowInputColumn
 
 	switch (start_boundary) {
 	case WindowBoundary::UNBOUNDED_PRECEDING:
-		window_start = partition_start;
+		window_start = NumericCast<int64_t>(partition_start);
 		break;
 	case WindowBoundary::CURRENT_ROW_ROWS:
-		window_start = row_idx;
+		window_start = NumericCast<int64_t>(row_idx);
 		break;
 	case WindowBoundary::CURRENT_ROW_RANGE:
-		window_start = peer_start;
+		window_start = NumericCast<int64_t>(peer_start);
 		break;
 	case WindowBoundary::EXPR_PRECEDING_ROWS: {
 		if (!TrySubtractOperator::Operation(int64_t(row_idx), boundary_start.GetCell<int64_t>(chunk_idx),
@@ -475,21 +475,21 @@ void WindowBoundariesState::Update(const idx_t row_idx, const WindowInputColumn
 	}
 	case WindowBoundary::EXPR_PRECEDING_RANGE: {
 		if (boundary_start.CellIsNull(chunk_idx)) {
-			window_start = peer_start;
+			window_start = NumericCast<int64_t>(peer_start);
 		} else {
 			prev.start = FindOrderedRangeBound<true>(range_collection, range_sense, valid_start, row_idx,
 			                                         start_boundary, boundary_start, chunk_idx, prev);
-			window_start = prev.start;
+			window_start = NumericCast<int64_t>(prev.start);
 		}
 		break;
 	}
 	case WindowBoundary::EXPR_FOLLOWING_RANGE: {
 		if (boundary_start.CellIsNull(chunk_idx)) {
-			window_start = peer_start;
+			window_start = NumericCast<int64_t>(peer_start);
 		} else {
 			prev.start = FindOrderedRangeBound<true>(range_collection, range_sense, row_idx, valid_end, start_boundary,
 			                                         boundary_start, chunk_idx, prev);
-			window_start = prev.start;
+			window_start = NumericCast<int64_t>(prev.start);
 		}
 		break;
 	}
@@ -499,13 +499,13 @@ void WindowBoundariesState::Update(const idx_t row_idx, const WindowInputColumn
 
 	switch (end_boundary) {
 	case WindowBoundary::CURRENT_ROW_ROWS:
-		window_end = row_idx + 1;
+		window_end = NumericCast<int64_t>(row_idx + 1);
 		break;
 	case WindowBoundary::CURRENT_ROW_RANGE:
-		window_end = peer_end;
+		window_end = NumericCast<int64_t>(peer_end);
 		break;
 	case WindowBoundary::UNBOUNDED_FOLLOWING:
-		window_end = partition_end;
+		window_end = NumericCast<int64_t>(partition_end);
 		break;
 	case WindowBoundary::EXPR_PRECEDING_ROWS:
 		if (!TrySubtractOperator::Operation(int64_t(row_idx + 1), boundary_end.GetCell<int64_t>(chunk_idx),
@@ -520,21 +520,21 @@ void WindowBoundariesState::Update(const idx_t row_idx, const WindowInputColumn
 		break;
 	case WindowBoundary::EXPR_PRECEDING_RANGE: {
 		if (boundary_end.CellIsNull(chunk_idx)) {
-			window_end = peer_end;
+			window_end = NumericCast<int64_t>(peer_end);
 		} else {
 			prev.end = FindOrderedRangeBound<false>(range_collection, range_sense, valid_start, row_idx, end_boundary,
 			                                        boundary_end, chunk_idx, prev);
-			window_end = prev.end;
+			window_end = NumericCast<int64_t>(prev.end);
 		}
 		break;
 	}
 	case WindowBoundary::EXPR_FOLLOWING_RANGE: {
 		if (boundary_end.CellIsNull(chunk_idx)) {
-			window_end = peer_end;
+			window_end = NumericCast<int64_t>(peer_end);
 		} else {
 			prev.end = FindOrderedRangeBound<false>(range_collection, range_sense, row_idx, valid_end, end_boundary,
 			                                        boundary_end, chunk_idx, prev);
-			window_end = prev.end;
+			window_end = NumericCast<int64_t>(prev.end);
 		}
 		break;
 	}
@@ -543,17 +543,17 @@ void WindowBoundariesState::Update(const idx_t row_idx, const WindowInputColumn
 	}
 
 	// clamp windows to partitions if they should exceed
-	if (window_start < (int64_t)partition_start) {
-		window_start = partition_start;
+	if (window_start < NumericCast<int64_t>(partition_start)) {
+		window_start = NumericCast<int64_t>(partition_start);
 	}
-	if (window_start > (int64_t)partition_end) {
-		window_start = partition_end;
+	if (window_start > NumericCast<int64_t>(partition_end)) {
+		window_start = NumericCast<int64_t>(partition_end);
 	}
-	if (window_end < (int64_t)partition_start) {
-		window_end = partition_start;
+	if (window_end < NumericCast<int64_t>(partition_start)) {
+		window_end = NumericCast<int64_t>(partition_start);
 	}
-	if (window_end > (int64_t)partition_end) {
-		window_end = partition_end;
+	if (window_end > NumericCast<int64_t>(partition_end)) {
+		window_end = NumericCast<int64_t>(partition_end);
 	}
 
 	if (window_start < 0 || window_end < 0) {
@@ -1029,7 +1029,7 @@ void WindowAggregateExecutor::Finalize() {
 	//	Estimate the frame statistics
 	//	Default to the entire partition if we don't know anything
 	FrameStats stats;
-	const int64_t count = aggregator->GetInputs().size();
+	const auto count = NumericCast<int64_t>(aggregator->GetInputs().size());
 
 	//	First entry is the frame start
 	stats[0] = FrameDelta(-count, count);
@@ -1090,7 +1090,7 @@ void WindowRowNumberExecutor::EvaluateInternal(WindowExecutorState &lstate, Vect
 	auto partition_begin = FlatVector::GetData<const idx_t>(lbstate.bounds.data[PARTITION_BEGIN]);
 	auto rdata = FlatVector::GetData<int64_t>(result);
 	for (idx_t i = 0; i < count; ++i, ++row_idx) {
-		rdata[i] = row_idx - partition_begin[i] + 1;
+		rdata[i] = NumericCast<int64_t>(row_idx - partition_begin[i] + 1);
 	}
 }
 
@@ -1147,7 +1147,7 @@ void WindowRankExecutor::EvaluateInternal(WindowExecutorState &lstate, Vector &r
 
 	for (idx_t i = 0; i < count; ++i, ++row_idx) {
 		lpeer.NextRank(partition_begin[i], peer_begin[i], row_idx);
-		rdata[i] = lpeer.rank;
+		rdata[i] = NumericCast<int64_t>(lpeer.rank);
 	}
 }
 
@@ -1209,7 +1209,7 @@ void WindowDenseRankExecutor::EvaluateInternal(WindowExecutorState &lstate, Vect
 
 	for (idx_t i = 0; i < count; ++i, ++row_idx) {
 		lpeer.NextRank(partition_begin[i], peer_begin[i], row_idx);
-		rdata[i] = lpeer.dense_rank;
+		rdata[i] = NumericCast<int64_t>(lpeer.dense_rank);
 	}
 }
 
@@ -1237,7 +1237,7 @@ void WindowPercentRankExecutor::EvaluateInternal(WindowExecutorState &lstate, Ve
 
 	for (idx_t i = 0; i < count; ++i, ++row_idx) {
 		lpeer.NextRank(partition_begin[i], peer_begin[i], row_idx);
-		int64_t denom = partition_end[i] - partition_begin[i] - 1;
+		auto denom = NumericCast<int64_t>(partition_end[i] - partition_begin[i] - 1);
 		double percent_rank = denom > 0 ? ((double)lpeer.rank - 1) / denom : 0;
 		rdata[i] = percent_rank;
 	}
@@ -1260,7 +1260,7 @@ void WindowCumeDistExecutor::EvaluateInternal(WindowExecutorState &lstate, Vecto
 	auto peer_end = FlatVector::GetData<const idx_t>(lbstate.bounds.data[PEER_END]);
 	auto rdata = FlatVector::GetData<double>(result);
 	for (idx_t i = 0; i < count; ++i, ++row_idx) {
-		int64_t denom = partition_end[i] - partition_begin[i];
+		auto denom = NumericCast<int64_t>(partition_end[i] - partition_begin[i]);
 		double cume_dist = denom > 0 ? ((double)(peer_end[i] - partition_begin[i])) / denom : 0;
 		rdata[i] = cume_dist;
 	}
@@ -1365,7 +1365,7 @@ void WindowNtileExecutor::EvaluateInternal(WindowExecutorState &lstate, Vector &
 				throw InvalidInputException("Argument for ntile must be greater than zero");
 			}
 			// With thanks from SQLite's ntileValueFunc()
-			int64_t n_total = partition_end[i] - partition_begin[i];
+			auto n_total = NumericCast<int64_t>(partition_end[i] - partition_begin[i]);
 			if (n_param > n_total) {
 				// more groups allowed than we have values
 				// map every entry to a unique group
@@ -1374,7 +1374,7 @@ void WindowNtileExecutor::EvaluateInternal(WindowExecutorState &lstate, Vector &
 			int64_t n_size = (n_total / n_param);
 			// find the row idx within the group
 			D_ASSERT(row_idx >= partition_begin[i]);
-			int64_t adjusted_row_idx = row_idx - partition_begin[i];
+			auto adjusted_row_idx = NumericCast<int64_t>(row_idx - partition_begin[i]);
 			// now compute the ntile
 			int64_t n_large = n_total - n_param * n_size;
 			int64_t i_small = n_large * (n_size + 1);
@@ -1452,16 +1452,16 @@ void WindowLeadLagExecutor::EvaluateInternal(WindowExecutorState &lstate, Vector
 		idx_t delta = 0;
 		if (val_idx < (int64_t)row_idx) {
 			// Count backwards
-			delta = idx_t(row_idx - val_idx);
-			val_idx = FindPrevStart(ignore_nulls, partition_begin[i], row_idx, delta);
+			delta = idx_t(row_idx - idx_t(val_idx));
+			val_idx = int64_t(FindPrevStart(ignore_nulls, partition_begin[i], row_idx, delta));
 		} else if (val_idx > (int64_t)row_idx) {
-			delta = idx_t(val_idx - row_idx);
-			val_idx = FindNextStart(ignore_nulls, row_idx + 1, partition_end[i], delta);
+			delta = idx_t(idx_t(val_idx) - row_idx);
+			val_idx = int64_t(FindNextStart(ignore_nulls, row_idx + 1, partition_end[i], delta));
 		}
 		// else offset is zero, so don't move.
 
 		if (!delta) {
-			CopyCell(payload_collection, 0, val_idx, result, i);
+			CopyCell(payload_collection, 0, NumericCast<idx_t>(val_idx), result, i);
 		} else if (wexpr.default_expr) {
 			llstate.leadlag_default.CopyCell(result, i);
 		} else {

package/src/duckdb/src/execution/window_segment_tree.cpp

@@ -1157,13 +1157,16 @@ void WindowDistinctAggregator::Sink(DataChunk &arg_chunk, SelectionVector *filte
 	//	3: 	for i ← 0 to in.size do
 	//	4: 		sorted[i] ← (in[i], i)
 	const auto count = arg_chunk.size();
-	auto payload_data = FlatVector::GetData<idx_t>(payload_chunk.data[0]);
-	std::iota(payload_data, payload_data + count, payload_pos);
+	payload_chunk.Reset();
+	auto &sorted_vec = payload_chunk.data[0];
+	auto sorted = FlatVector::GetData<idx_t>(sorted_vec);
+	std::iota(sorted, sorted + count, payload_pos);
 	payload_pos += count;
 
 	for (column_t c = 0; c < arg_chunk.ColumnCount(); ++c) {
 		sort_chunk.data[c].Reference(arg_chunk.data[c]);
 	}
+	sort_chunk.data.back().Reference(sorted_vec);
 	sort_chunk.SetCardinality(arg_chunk);
 	payload_chunk.SetCardinality(sort_chunk);
 

package/src/duckdb/src/function/aggregate/distributive/first.cpp

@@ -88,7 +88,7 @@ struct FirstFunctionString : public FirstFunctionBase {
 				auto ptr = LAST ? new char[len] : char_ptr_cast(input_data.allocator.Allocate(len));
 				memcpy(ptr, value.GetData(), len);
 
-				state.value = string_t(ptr, UnsafeNumericCast<int>(len));
+				state.value = string_t(ptr, UnsafeNumericCast<uint32_t>(len));
 			}
 		}
 	}

package/src/duckdb/src/function/cast/string_cast.cpp

@@ -161,7 +161,7 @@ bool VectorStringToList::StringToNestedTypeCastLoop(const string_t *source_data,
 		if (!VectorStringToList::SplitStringList(source_data[idx], child_data, total, varchar_vector)) {
 			string text = "Type VARCHAR with value '" + source_data[idx].GetString() +
 			              "' can't be cast to the destination type LIST";
-			HandleVectorCastError::Operation<string_t>(text, result_mask, idx, vector_cast_data);
+			HandleVectorCastError::Operation<string_t>(text, result_mask, i, vector_cast_data);
 		}
 		list_data[i].length = total - list_data[i].offset; // length is the amount of parts coming from this string
 	}
@@ -412,7 +412,7 @@ bool VectorStringToArray::StringToNestedTypeCastLoop(const string_t *source_data
 
 			// Null the entire array
 			for (idx_t j = 0; j < array_size; j++) {
-				FlatVector::SetNull(varchar_vector, idx * array_size + j, true);
+				FlatVector::SetNull(varchar_vector, i * array_size + j, true);
 			}
 
 			total += array_size;
@@ -422,7 +422,7 @@ bool VectorStringToArray::StringToNestedTypeCastLoop(const string_t *source_data
 		if (!VectorStringToList::SplitStringList(source_data[idx], child_data, total, varchar_vector)) {
 			auto text = StringUtil::Format("Type VARCHAR with value '%s' can't be cast to the destination type ARRAY",
 			                               source_data[idx].GetString());
-			HandleVectorCastError::Operation<string_t>(text, result_mask, idx, vector_cast_data);
+			HandleVectorCastError::Operation<string_t>(text, result_mask, i, vector_cast_data);
 		}
 	}
 	D_ASSERT(total == child_count);

package/src/duckdb/src/function/cast_rules.cpp

@@ -211,6 +211,7 @@ static int64_t ImplicitCastUhugeint(const LogicalType &to) {
 static int64_t ImplicitCastDate(const LogicalType &to) {
 	switch (to.id()) {
 	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
 		return TargetTypeCost(to);
 	default:
 		return -1;

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

@@ -158,8 +158,8 @@ void Function::EraseArgument(SimpleFunction &bound_function, vector<unique_ptr<E
 	}
 	D_ASSERT(arguments.size() == bound_function.arguments.size());
 	D_ASSERT(argument_index < arguments.size());
-	arguments.erase(arguments.begin() + argument_index);
-	bound_function.arguments.erase(bound_function.arguments.begin() + argument_index);
+	arguments.erase_at(argument_index);
+	bound_function.arguments.erase_at(argument_index);
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/function_binder.cpp

@@ -279,7 +279,7 @@ void FunctionBinder::CastToFunctionArguments(SimpleFunction &function, vector<un
 
 unique_ptr<Expression> FunctionBinder::BindScalarFunction(const string &schema, const string &name,
                                                           vector<unique_ptr<Expression>> children, ErrorData &error,
-                                                          bool is_operator, Binder *binder) {
+                                                          bool is_operator, optional_ptr<Binder> binder) {
 	// bind the function
 	auto &function =
 	    Catalog::GetSystemCatalog(context).GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, schema, name);
@@ -290,7 +290,7 @@ unique_ptr<Expression> FunctionBinder::BindScalarFunction(const string &schema,
 
 unique_ptr<Expression> FunctionBinder::BindScalarFunction(ScalarFunctionCatalogEntry &func,
                                                           vector<unique_ptr<Expression>> children, ErrorData &error,
-                                                          bool is_operator, Binder *binder) {
+                                                          bool is_operator, optional_ptr<Binder> binder) {
 	// bind the function
 	auto best_function = BindFunction(func.name, func.functions, children, error);
 	if (!best_function.IsValid()) {
@@ -335,16 +335,21 @@ unique_ptr<Expression> FunctionBinder::BindScalarFunction(ScalarFunctionCatalogE
 			}
 		}
 	}
-	return BindScalarFunction(bound_function, std::move(children), is_operator);
+	return BindScalarFunction(bound_function, std::move(children), is_operator, binder);
 }
 
 unique_ptr<BoundFunctionExpression> FunctionBinder::BindScalarFunction(ScalarFunction bound_function,
                                                                        vector<unique_ptr<Expression>> children,
-                                                                       bool is_operator) {
+                                                                       bool is_operator, optional_ptr<Binder> binder) {
 	unique_ptr<FunctionData> bind_info;
 	if (bound_function.bind) {
 		bind_info = bound_function.bind(context, bound_function, children);
 	}
+	if (bound_function.get_modified_databases && binder) {
+		auto &properties = binder->GetStatementProperties();
+		FunctionModifiedDatabasesInput input(bind_info, properties.modified_databases);
+		bound_function.get_modified_databases(input);
+	}
 	// check if we need to add casts to the children
 	CastToFunctionArguments(bound_function, children);
 

package/src/duckdb/src/function/pragma/pragma_functions.cpp

@@ -2,6 +2,8 @@
 
 #include "duckdb/common/enums/output_type.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
+#include "duckdb/function/function_set.hpp"
+#include "duckdb/logging/http_logger.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/main/query_profiler.hpp"
@@ -10,7 +12,6 @@
 #include "duckdb/planner/expression_binder.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
 #include "duckdb/storage/storage_manager.hpp"
-#include "duckdb/function/function_set.hpp"
 
 #include <cctype>
 

package/src/duckdb/src/function/pragma/pragma_queries.cpp

@@ -3,9 +3,10 @@
 #include "duckdb/common/file_system.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/function/pragma/pragma_functions.hpp"
+#include "duckdb/main/client_data.hpp"
 #include "duckdb/main/config.hpp"
 #include "duckdb/main/database_manager.hpp"
-#include "duckdb/main/client_data.hpp"
+#include "duckdb/main/extension_helper.hpp"
 #include "duckdb/parser/parser.hpp"
 #include "duckdb/parser/qualified_name.hpp"
 #include "duckdb/parser/statement/copy_statement.hpp"
@@ -141,9 +142,9 @@ string PragmaImportDatabase(ClientContext &context, const FunctionParameters &pa
 		auto file_path = fs.JoinPath(parameters.values[0].ToString(), file);
 		auto handle = fs.OpenFile(file_path, FileFlags::FILE_FLAGS_READ);
 		auto fsize = fs.GetFileSize(*handle);
-		auto buffer = make_unsafe_uniq_array<char>(fsize);
+		auto buffer = make_unsafe_uniq_array<char>(UnsafeNumericCast<size_t>(fsize));
 		fs.Read(*handle, buffer.get(), fsize);
-		auto query = string(buffer.get(), fsize);
+		auto query = string(buffer.get(), UnsafeNumericCast<uint32_t>(fsize));
 		// Replace the placeholder with the path provided to IMPORT
 		if (file == "load.sql") {
 			Parser parser;

package/src/duckdb/src/function/scalar/compressed_materialization/compress_string.cpp

@@ -39,7 +39,7 @@ static inline RESULT_TYPE StringCompressInternal(const string_t &input) {
 		ReverseMemCpy(result_ptr + remainder, data_ptr_cast(input.GetPointer()), input.GetSize());
 		memset(result_ptr, '\0', remainder);
 	}
-	result_ptr[0] = UnsafeNumericCast<char>(input.GetSize());
+	result_ptr[0] = UnsafeNumericCast<data_t>(input.GetSize());
 	return result;
 }
 

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

@@ -62,13 +62,14 @@ void ListExtractTemplate(idx_t count, UnifiedVectorFormat &list_data, UnifiedVec
 				result_mask.SetInvalid(i);
 				continue;
 			}
-			child_offset = list_entry.offset + list_entry.length + offsets_entry;
+			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 = list_entry.offset + offsets_entry;
+			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)) {

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

@@ -28,7 +28,7 @@ void ListResizeFunction(DataChunk &args, ExpressionState &state, Vector &result)
 
 	UnifiedVectorFormat new_size_data;
 	new_sizes.ToUnifiedFormat(count, new_size_data);
-	auto new_size_entries = UnifiedVectorFormat::GetData<int64_t>(new_size_data);
+	auto new_size_entries = UnifiedVectorFormat::GetData<uint64_t>(new_size_data);
 
 	UnifiedVectorFormat child_data;
 	child.ToUnifiedFormat(count, child_data);

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

@@ -12,10 +12,11 @@ struct SetSelectionVectorSelect {
 	                               ValidityMask &input_validity, Vector &selection_entry, idx_t child_idx,
 	                               idx_t &target_offset, idx_t selection_offset, idx_t input_offset,
 	                               idx_t target_length) {
-		idx_t sel_idx = selection_entry.GetValue(selection_offset + child_idx).GetValue<int64_t>() - 1;
-		if (sel_idx < target_length) {
-			selection_vector.set_index(target_offset, input_offset + sel_idx);
-			if (!input_validity.RowIsValid(input_offset + sel_idx)) {
+		auto sel_idx = selection_entry.GetValue(selection_offset + child_idx).GetValue<int64_t>() - 1;
+		if (sel_idx >= 0 && sel_idx < UnsafeNumericCast<int64_t>(target_length)) {
+			auto sel_idx_unsigned = UnsafeNumericCast<idx_t>(sel_idx);
+			selection_vector.set_index(target_offset, input_offset + sel_idx_unsigned);
+			if (!input_validity.RowIsValid(input_offset + sel_idx_unsigned)) {
 				validity_mask.SetInvalid(target_offset);
 			}
 		} else {
@@ -44,6 +45,12 @@ struct SetSelectionVectorWhere {
 		if (!input_validity.RowIsValid(input_offset + child_idx)) {
 			validity_mask.SetInvalid(target_offset);
 		}
+
+		if (child_idx >= target_length) {
+			selection_vector.set_index(target_offset, 0);
+			validity_mask.SetInvalid(target_offset);
+		}
+
 		target_offset++;
 	}
 

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

@@ -143,8 +143,10 @@ static unique_ptr<FunctionData> ListZipBind(ClientContext &context, ScalarFuncti
 		case LogicalTypeId::SQLNULL:
 			struct_children.push_back(make_pair(string(), LogicalTypeId::SQLNULL));
 			break;
-		default:
+		case LogicalTypeId::UNKNOWN:
 			throw ParameterNotResolvedException();
+		default:
+			throw BinderException("Parameter type needs to be List");
 		}
 	}
 	bound_function.return_type = LogicalType::LIST(LogicalType::STRUCT(struct_children));

package/src/duckdb/src/function/scalar/operators/add.cpp

@@ -36,15 +36,8 @@ interval_t AddOperator::Operation(interval_t left, interval_t right) {
 
 template <>
 date_t AddOperator::Operation(date_t left, int32_t right) {
-	if (!Value::IsFinite(left)) {
-		return left;
-	}
-	int32_t days;
-	if (!TryAddOperator::Operation(left.days, right, days)) {
-		throw OutOfRangeException("Date out of range");
-	}
-	date_t result(days);
-	if (!Value::IsFinite(result)) {
+	date_t result;
+	if (!TryAddOperator::Operation(left, right, result)) {
 		throw OutOfRangeException("Date out of range");
 	}
 	return result;
@@ -154,6 +147,23 @@ bool TryAddOperator::Operation(uint64_t left, uint64_t right, uint64_t &result)
 	return OverflowCheckedAddition::Operation<uint64_t, uint64_t>(left, right, result);
 }
 
+template <>
+bool TryAddOperator::Operation(date_t left, int32_t right, date_t &result) {
+	if (left == date_t::infinity() || left == date_t::ninfinity()) {
+		result = date_t(left);
+		return true;
+	}
+	int32_t days;
+	if (!TryAddOperator::Operation(left.days, right, days)) {
+		return false;
+	}
+	result.days = days;
+	if (!Value::IsFinite(result)) {
+		return false;
+	}
+	return true;
+}
+
 template <>
 bool TryAddOperator::Operation(int8_t left, int8_t right, int8_t &result) {
 	return OverflowCheckedAddition::Operation<int8_t, int16_t>(left, right, result);