duckdb 0.10.1-dev9.0 → 0.10.2-dev0.0

package/src/duckdb/src/execution/physical_plan/plan_limit.cpp

@@ -1,32 +1,64 @@
 #include "duckdb/execution/operator/helper/physical_limit.hpp"
 #include "duckdb/execution/operator/helper/physical_streaming_limit.hpp"
+#include "duckdb/execution/operator/helper/physical_limit_percent.hpp"
 #include "duckdb/execution/physical_plan_generator.hpp"
 #include "duckdb/main/config.hpp"
 #include "duckdb/planner/operator/logical_limit.hpp"
 
 namespace duckdb {
 
+bool UseBatchLimit(BoundLimitNode &limit_val, BoundLimitNode &offset_val) {
+#ifdef DUCKDB_ALTERNATIVE_VERIFY
+	return true;
+#else
+	// we only use batch limit when we are computing a small amount of values
+	// as the batch limit materializes this many rows PER thread
+	static constexpr const idx_t BATCH_LIMIT_THRESHOLD = 10000;
+
+	if (limit_val.Type() != LimitNodeType::CONSTANT_VALUE) {
+		return false;
+	}
+	if (offset_val.Type() == LimitNodeType::EXPRESSION_VALUE) {
+		return false;
+	}
+	idx_t total_offset = limit_val.GetConstantValue();
+	if (offset_val.Type() == LimitNodeType::CONSTANT_VALUE) {
+		total_offset += offset_val.GetConstantValue();
+	}
+	return total_offset <= BATCH_LIMIT_THRESHOLD;
+#endif
+}
+
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalLimit &op) {
 	D_ASSERT(op.children.size() == 1);
 
 	auto plan = CreatePlan(*op.children[0]);
 
 	unique_ptr<PhysicalOperator> limit;
-	if (!PreserveInsertionOrder(*plan)) {
-		// use parallel streaming limit if insertion order is not important
-		limit = make_uniq<PhysicalStreamingLimit>(op.types, (idx_t)op.limit_val, op.offset_val, std::move(op.limit),
-		                                          std::move(op.offset), op.estimated_cardinality, true);
-	} else {
-		// maintaining insertion order is important
-		if (UseBatchIndex(*plan)) {
-			// source supports batch index: use parallel batch limit
-			limit = make_uniq<PhysicalLimit>(op.types, (idx_t)op.limit_val, op.offset_val, std::move(op.limit),
-			                                 std::move(op.offset), op.estimated_cardinality);
+	switch (op.limit_val.Type()) {
+	case LimitNodeType::EXPRESSION_PERCENTAGE:
+	case LimitNodeType::CONSTANT_PERCENTAGE:
+		limit = make_uniq<PhysicalLimitPercent>(op.types, std::move(op.limit_val), std::move(op.offset_val),
+		                                        op.estimated_cardinality);
+		break;
+	default:
+		if (!PreserveInsertionOrder(*plan)) {
+			// use parallel streaming limit if insertion order is not important
+			limit = make_uniq<PhysicalStreamingLimit>(op.types, std::move(op.limit_val), std::move(op.offset_val),
+			                                          op.estimated_cardinality, true);
 		} else {
-			// source does not support batch index: use a non-parallel streaming limit
-			limit = make_uniq<PhysicalStreamingLimit>(op.types, (idx_t)op.limit_val, op.offset_val, std::move(op.limit),
-			                                          std::move(op.offset), op.estimated_cardinality, false);
+			// maintaining insertion order is important
+			if (UseBatchIndex(*plan) && UseBatchLimit(op.limit_val, op.offset_val)) {
+				// source supports batch index: use parallel batch limit
+				limit = make_uniq<PhysicalLimit>(op.types, std::move(op.limit_val), std::move(op.offset_val),
+				                                 op.estimated_cardinality);
+			} else {
+				// source does not support batch index: use a non-parallel streaming limit
+				limit = make_uniq<PhysicalStreamingLimit>(op.types, std::move(op.limit_val), std::move(op.offset_val),
+				                                          op.estimated_cardinality, false);
+			}
 		}
+		break;
 	}
 
 	limit->children.push_back(std::move(plan));

package/src/duckdb/src/execution/physical_plan/ub_duckdb_physical_plan.cpp

@@ -0,0 +1,44 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_aggregate.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_any_join.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_asof_join.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_column_data_get.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_comparison_join.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_copy_to_file.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_create.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_create_index.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_create_table.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_cross_product.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_delete.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_delim_get.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_delim_join.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_distinct.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_dummy_scan.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_empty_result.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_execute.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_explain.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_export.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_filter.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_get.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_insert.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_limit.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_limit_percent.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_order.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_pivot.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_positional_join.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_pragma.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_prepare.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_projection.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_set_operation.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_set.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_reset.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_sample.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_show_select.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_simple.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_top_n.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_update.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_window.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_unnest.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_expression_get.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_recursive_cte.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan/plan_cte.cpp>

package/src/duckdb/src/execution/physical_plan_generator.cpp

@@ -9,6 +9,7 @@
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/planner/operator/logical_extension_operator.hpp"
 #include "duckdb/planner/operator/list.hpp"
+#include "duckdb/execution/operator/helper/physical_verify_vector.hpp"
 
 namespace duckdb {
 
@@ -92,9 +93,6 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalOperator &
 	case LogicalOperatorType::LOGICAL_LIMIT:
 		plan = CreatePlan(op.Cast<LogicalLimit>());
 		break;
-	case LogicalOperatorType::LOGICAL_LIMIT_PERCENT:
-		plan = CreatePlan(op.Cast<LogicalLimitPercent>());
-		break;
 	case LogicalOperatorType::LOGICAL_SAMPLE:
 		plan = CreatePlan(op.Cast<LogicalSample>());
 		break;
@@ -229,6 +227,10 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalOperator &
 	}
 
 	plan->estimated_cardinality = op.estimated_cardinality;
+#ifdef DUCKDB_VERIFY_VECTOR_OPERATOR
+	auto verify = make_uniq<PhysicalVerifyVector>(std::move(plan));
+	plan = std::move(verify);
+#endif
 
 	return plan;
 }

package/src/duckdb/src/execution/radix_partitioned_hashtable.cpp

@@ -289,10 +289,9 @@ idx_t RadixHTConfig::ExternalRadixBits(const idx_t &maximum_sink_radix_bits_p) {
 idx_t RadixHTConfig::SinkCapacity(ClientContext &context) {
 	// Get active and maximum number of threads
 	const idx_t active_threads = TaskScheduler::GetScheduler(context).NumberOfThreads();
-	const auto max_threads = DBConfig::GetConfig(context).options.maximum_threads;
 
 	// Compute cache size per active thread (assuming cache is shared)
-	const auto total_shared_cache_size = max_threads * L3_CACHE_SIZE;
+	const auto total_shared_cache_size = active_threads * L3_CACHE_SIZE;
 	const auto cache_per_active_thread = L1_CACHE_SIZE + L2_CACHE_SIZE + total_shared_cache_size / active_threads;
 
 	// Divide cache per active thread by entry size, round up to next power of two, to get capacity
@@ -348,7 +347,8 @@ void RadixPartitionedHashTable::PopulateGroupChunk(DataChunk &group_chunk, DataC
 	group_chunk.Verify();
 }
 
-bool MaybeRepartition(ClientContext &context, RadixHTGlobalSinkState &gstate, RadixHTLocalSinkState &lstate) {
+bool MaybeRepartition(ClientContext &context, RadixHTGlobalSinkState &gstate, RadixHTLocalSinkState &lstate,
+                      const idx_t &active_threads) {
 	auto &config = gstate.config;
 	auto &ht = *lstate.ht;
 	auto &partitioned_data = ht.GetPartitionedData();
@@ -356,19 +356,19 @@ bool MaybeRepartition(ClientContext &context, RadixHTGlobalSinkState &gstate, Ra
 	// Check if we're approaching the memory limit
 	auto &temporary_memory_state = *gstate.temporary_memory_state;
 	const auto total_size = partitioned_data->SizeInBytes() + ht.Capacity() * sizeof(aggr_ht_entry_t);
-	idx_t thread_limit = temporary_memory_state.GetReservation() / gstate.active_threads;
+	idx_t thread_limit = temporary_memory_state.GetReservation() / active_threads;
 	if (total_size > thread_limit) {
 		// We're over the thread memory limit
 		if (!gstate.external) {
 			// We haven't yet triggered out-of-core behavior, but maybe we don't have to, grab the lock and check again
 			lock_guard<mutex> guard(gstate.lock);
-			thread_limit = temporary_memory_state.GetReservation() / gstate.active_threads;
+			thread_limit = temporary_memory_state.GetReservation() / active_threads;
 			if (total_size > thread_limit) {
 				// Out-of-core would be triggered below, try to increase the reservation
 				auto remaining_size =
-				    MaxValue<idx_t>(gstate.active_threads * total_size, temporary_memory_state.GetRemainingSize());
+				    MaxValue<idx_t>(active_threads * total_size, temporary_memory_state.GetRemainingSize());
 				temporary_memory_state.SetRemainingSize(context, 2 * remaining_size);
-				thread_limit = temporary_memory_state.GetReservation() / gstate.active_threads;
+				thread_limit = temporary_memory_state.GetReservation() / active_threads;
 			}
 		}
 	}
@@ -391,7 +391,7 @@ bool MaybeRepartition(ClientContext &context, RadixHTGlobalSinkState &gstate, Ra
 	}
 
 	// We can go external when there is only one active thread, but we shouldn't repartition here
-	if (gstate.active_threads < 2) {
+	if (active_threads < 2) {
 		return false;
 	}
 
@@ -439,7 +439,8 @@ void RadixPartitionedHashTable::Sink(ExecutionContext &context, DataChunk &chunk
 		return; // We can fit another chunk
 	}
 
-	if (gstate.active_threads > 2) {
+	const idx_t active_threads = gstate.active_threads;
+	if (active_threads > 2) {
 		// 'Reset' the HT without taking its data, we can just keep appending to the same collection
 		// This only works because we never resize the HT
 		ht.ClearPointerTable();
@@ -448,7 +449,7 @@ void RadixPartitionedHashTable::Sink(ExecutionContext &context, DataChunk &chunk
 	}
 
 	// Check if we need to repartition
-	auto repartitioned = MaybeRepartition(context.client, gstate, lstate);
+	auto repartitioned = MaybeRepartition(context.client, gstate, lstate, active_threads);
 
 	if (repartitioned && ht.Count() != 0) {
 		// We repartitioned, but we didn't clear the pointer table / reset the count because we're on 1 or 2 threads
@@ -469,7 +470,7 @@ void RadixPartitionedHashTable::Combine(ExecutionContext &context, GlobalSinkSta
 
 	// Set any_combined, then check one last time whether we need to repartition
 	gstate.any_combined = true;
-	MaybeRepartition(context.client, gstate, lstate);
+	MaybeRepartition(context.client, gstate, lstate, gstate.active_threads);
 
 	auto &ht = *lstate.ht;
 	ht.UnpinData();
@@ -579,7 +580,7 @@ public:
 	//! For synchronizing scan tasks
 	mutex lock;
 	idx_t scan_idx;
-	idx_t scan_done;
+	atomic<idx_t> scan_done;
 };
 
 enum class RadixHTScanStatus : uint8_t { INIT, IN_PROGRESS, DONE };

package/src/duckdb/src/execution/ub_duckdb_execution.cpp

@@ -0,0 +1,15 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/execution/adaptive_filter.cpp>
+#include </Users/carlo/duckdb/src/execution/aggregate_hashtable.cpp>
+#include </Users/carlo/duckdb/src/execution/base_aggregate_hashtable.cpp>
+#include </Users/carlo/duckdb/src/execution/column_binding_resolver.cpp>
+#include </Users/carlo/duckdb/src/execution/expression_executor.cpp>
+#include </Users/carlo/duckdb/src/execution/expression_executor_state.cpp>
+#include </Users/carlo/duckdb/src/execution/join_hashtable.cpp>
+#include </Users/carlo/duckdb/src/execution/perfect_aggregate_hashtable.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_operator.cpp>
+#include </Users/carlo/duckdb/src/execution/physical_plan_generator.cpp>
+#include </Users/carlo/duckdb/src/execution/radix_partitioned_hashtable.cpp>
+#include </Users/carlo/duckdb/src/execution/reservoir_sample.cpp>
+#include </Users/carlo/duckdb/src/execution/window_executor.cpp>
+#include </Users/carlo/duckdb/src/execution/window_segment_tree.cpp>

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

@@ -207,19 +207,24 @@ static idx_t FindTypedRangeBound(const WindowInputColumn &over, const idx_t orde
 	WindowColumnIterator<T> begin(over, order_begin);
 	WindowColumnIterator<T> end(over, order_end);
 
-	if (order_begin < prev.start && prev.start < order_end) {
-		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);
+	//	Try to reuse the previous bounds to restrict the search.
+	//	This is only valid if the previous bounds were non-empty
+	//	Only inject the comparisons if the previous bounds are a strict subset.
+	if (prev.start < prev.end) {
+		if (order_begin < prev.start && prev.start < order_end) {
+			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);
+			}
 		}
-	}
-	if (order_begin <= prev.end && prev.end < order_end) {
-		const auto second = over.GetCell<T>(prev.end);
-		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);
+		if (order_begin < prev.end && prev.end < order_end) {
+			const auto second = over.GetCell<T>(prev.end - 1);
+			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);
+			}
 		}
 	}
 
@@ -940,77 +945,81 @@ void WindowAggregateExecutor::Sink(DataChunk &input_chunk, const idx_t input_idx
 	WindowExecutor::Sink(input_chunk, input_idx, total_count);
 }
 
-void WindowAggregateExecutor::Finalize() {
-	D_ASSERT(aggregator);
-
-	//	Estimate the frame statistics
-	//	Default to the entire partition if we don't know anything
-	FrameStats stats;
-	const int64_t count = aggregator->GetInputs().size();
+static void ApplyWindowStats(const WindowBoundary &boundary, FrameDelta &delta, BaseStatistics *base, bool is_start) {
+	// Avoid overflow by clamping to the frame bounds
+	auto base_stats = delta;
 
-	//	First entry is the frame start
-	stats[0] = FrameDelta(-count, count);
-	auto base = wexpr.expr_stats.empty() ? nullptr : wexpr.expr_stats[0].get();
-	switch (wexpr.start) {
+	switch (boundary) {
 	case WindowBoundary::UNBOUNDED_PRECEDING:
-		stats[0].end = 0;
+		if (is_start) {
+			delta.end = 0;
+			return;
+		}
 		break;
-	case WindowBoundary::CURRENT_ROW_ROWS:
-		stats[0].begin = stats[0].end = 0;
+	case WindowBoundary::UNBOUNDED_FOLLOWING:
+		if (!is_start) {
+			delta.begin = 0;
+			return;
+		}
 		break;
+	case WindowBoundary::CURRENT_ROW_ROWS:
+		delta.begin = delta.end = 0;
+		return;
 	case WindowBoundary::EXPR_PRECEDING_ROWS:
 		if (base && base->GetStatsType() == StatisticsType::NUMERIC_STATS && NumericStats::HasMinMax(*base)) {
 			//	Preceding so negative offset from current row
-			stats[0].begin = -NumericStats::GetMax<int64_t>(*base);
-			stats[0].end = -NumericStats::GetMin<int64_t>(*base) + 1;
+			base_stats.begin = NumericStats::GetMin<int64_t>(*base);
+			base_stats.end = NumericStats::GetMax<int64_t>(*base);
+			if (delta.begin < base_stats.end && base_stats.end < delta.end) {
+				delta.begin = -base_stats.end;
+			}
+			if (delta.begin < base_stats.begin && base_stats.begin < delta.end) {
+				delta.end = -base_stats.begin + 1;
+			}
 		}
-		break;
+		return;
 	case WindowBoundary::EXPR_FOLLOWING_ROWS:
 		if (base && base->GetStatsType() == StatisticsType::NUMERIC_STATS && NumericStats::HasMinMax(*base)) {
-			stats[0].begin = NumericStats::GetMin<int64_t>(*base);
-			stats[0].end = NumericStats::GetMax<int64_t>(*base) + 1;
+			base_stats.begin = NumericStats::GetMin<int64_t>(*base);
+			base_stats.end = NumericStats::GetMax<int64_t>(*base);
+			if (base_stats.end < delta.end) {
+				delta.end = base_stats.end + 1;
+			}
 		}
-		break;
+		return;
 
 	case WindowBoundary::CURRENT_ROW_RANGE:
 	case WindowBoundary::EXPR_PRECEDING_RANGE:
 	case WindowBoundary::EXPR_FOLLOWING_RANGE:
-		break;
+		return;
 	default:
+		break;
+	}
+
+	if (is_start) {
 		throw InternalException("Unsupported window start boundary");
+	} else {
+		throw InternalException("Unsupported window end boundary");
 	}
+}
+
+void WindowAggregateExecutor::Finalize() {
+	D_ASSERT(aggregator);
+
+	//	Estimate the frame statistics
+	//	Default to the entire partition if we don't know anything
+	FrameStats stats;
+	const int64_t count = aggregator->GetInputs().size();
+
+	//	First entry is the frame start
+	stats[0] = FrameDelta(-count, count);
+	auto base = wexpr.expr_stats.empty() ? nullptr : wexpr.expr_stats[0].get();
+	ApplyWindowStats(wexpr.start, stats[0], base, true);
 
 	//	Second entry is the frame end
 	stats[1] = FrameDelta(-count, count);
 	base = wexpr.expr_stats.empty() ? nullptr : wexpr.expr_stats[1].get();
-	switch (wexpr.end) {
-	case WindowBoundary::UNBOUNDED_FOLLOWING:
-		stats[1].begin = 0;
-		break;
-	case WindowBoundary::CURRENT_ROW_ROWS:
-		stats[1].begin = stats[1].end = 0;
-		break;
-	case WindowBoundary::EXPR_PRECEDING_ROWS:
-		if (base && base->GetStatsType() == StatisticsType::NUMERIC_STATS && NumericStats::HasMinMax(*base)) {
-			//	Preceding so negative offset from current row
-			stats[1].begin = -NumericStats::GetMax<int64_t>(*base);
-			stats[1].end = -NumericStats::GetMin<int64_t>(*base) + 1;
-		}
-		break;
-	case WindowBoundary::EXPR_FOLLOWING_ROWS:
-		if (base && base->GetStatsType() == StatisticsType::NUMERIC_STATS && NumericStats::HasMinMax(*base)) {
-			stats[1].begin = NumericStats::GetMin<int64_t>(*base);
-			stats[1].end = NumericStats::GetMax<int64_t>(*base) + 1;
-		}
-		break;
-
-	case WindowBoundary::CURRENT_ROW_RANGE:
-	case WindowBoundary::EXPR_PRECEDING_RANGE:
-	case WindowBoundary::EXPR_FOLLOWING_RANGE:
-		break;
-	default:
-		throw InternalException("Unsupported window end boundary");
-	}
+	ApplyWindowStats(wexpr.end, stats[1], base, false);
 
 	aggregator->Finalize(stats);
 }
@@ -1282,6 +1291,7 @@ void WindowValueExecutor::Sink(DataChunk &input_chunk, const idx_t input_idx, co
 		if (check_nulls) {
 			const auto count = input_chunk.size();
 
+			payload_chunk.Flatten();
 			UnifiedVectorFormat vdata;
 			payload_chunk.data[0].ToUnifiedFormat(count, vdata);
 			if (!vdata.validity.AllValid()) {

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

@@ -509,7 +509,7 @@ size_t WindowNaiveState::Hash(idx_t rid) {
 	auto &inputs = const_cast<DataChunk &>(gstate.GetInputs());
 	leaves.Reference(inputs);
 
-	sel_t s = rid;
+	auto s = UnsafeNumericCast<sel_t>(rid);
 	SelectionVector sel(&s);
 	leaves.Slice(sel, 1);
 	leaves.Hash(hashes);
@@ -520,10 +520,10 @@ size_t WindowNaiveState::Hash(idx_t rid) {
 bool WindowNaiveState::KeyEqual(const idx_t &lhs, const idx_t &rhs) {
 	auto &inputs = const_cast<DataChunk &>(gstate.GetInputs());
 
-	sel_t l = lhs;
+	auto l = UnsafeNumericCast<sel_t>(lhs);
 	SelectionVector lsel(&l);
 
-	sel_t r = rhs;
+	auto r = UnsafeNumericCast<sel_t>(rhs);
 	SelectionVector rsel(&r);
 
 	sel_t f = 0;
@@ -565,7 +565,7 @@ void WindowNaiveState::Evaluate(const DataChunk &bounds, Vector &result, idx_t c
 				}
 
 				pdata[flush_count] = agg_state;
-				update_sel[flush_count++] = f;
+				update_sel[flush_count++] = UnsafeNumericCast<sel_t>(f);
 				if (flush_count >= STANDARD_VECTOR_SIZE) {
 					FlushStates();
 				}
@@ -616,7 +616,7 @@ void WindowSegmentTree::Finalize(const FrameStats &stats) {
 }
 
 WindowSegmentTree::~WindowSegmentTree() {
-	if (!aggr.function.destructor) {
+	if (!aggr.function.destructor || !gstate) {
 		// nothing to destroy
 		return;
 	}
@@ -1333,7 +1333,7 @@ WindowDistinctAggregator::DistinctSortTree::DistinctSortTree(ZippedElements &&pr
 				if (prev_idx < i + 1) {
 					updates[nupdate] = curr_state;
 					//	input_idx
-					sel[nupdate] = std::get<1>(zipped_level[j]);
+					sel[nupdate] = UnsafeNumericCast<sel_t>(std::get<1>(zipped_level[j]));
 					++nupdate;
 				}
 

package/src/duckdb/src/extension_forward_decl/icu.cpp

@@ -0,0 +1,59 @@
+
+namespace duckdb {
+
+struct ICUForward {
+
+	void (*func)(ClientContext &, TableFunctionInput &, DataChunk &);
+	unique_ptr<FunctionData> (*bind_func)(ClientContext &context, TableFunctionBindInput &input,
+	                                      vector<LogicalType> &return_types, vector<string> &names);
+	unique_ptr<GlobalTableFunctionState> (*init_func)(ClientContext &context, TableFunctionInitInput &input);
+
+	func myFunc = nullptr;
+	bind_func myBind1 = nullptr;
+	bind_func myBind2 = nullptr;
+	init_func myInit = nullptr;
+
+	static void ICUTableRangeFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+		if (!TryAutoLoad(context, "icu")) {
+			throw ExtensionExcetion("NOOOO");
+		}
+		(*myFunc)(context, data_p, output);
+	}
+
+	template <bool GENERATE_SERIES>
+	static unique_ptr<FunctionData> Bind(ClientContext &context, TableFunctionBindInput &input,
+	                                     vector<LogicalType> &return_types, vector<string> &names) {
+		if (!TryAutoLoad(context, "icu")) {
+			throw ExtensionExcetion("NOOOO");
+		}
+		if (GENERATE_SERIES)
+			return (*myBind1)(context, input, return_types, names);
+		else
+			return (*myBind2)(context, input, return_types, names);
+	}
+
+	static unique_ptr<GlobalTableFunctionState> Init(ClientContext &context, TableFunctionInitInput &input) {
+		if (!TryAutoLoad(context, "icu")) {
+			throw ExtensionExcetion("NOOOO");
+		}
+		return (*myInit)(context, input);
+	}
+
+	static void AddICUTableRangeFunction(ClientContext &context) {
+		auto &catalog = Catalog::GetSystemCatalog(context);
+
+		TableFunctionSet range("range");
+		range.AddFunction(TableFunction({LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL},
+		                                ICUTableRangeFunction, Bind<false>, Init));
+		CreateTableFunctionInfo range_func_info(range);
+		catalog.AddFunction(context, range_func_info);
+
+		// generate_series: similar to range, but inclusive instead of exclusive bounds on the RHS
+		TableFunctionSet generate_series("generate_series");
+		generate_series.AddFunction(
+		    TableFunction({LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL},
+		                  ICUTableRangeFunction, Bind<true>, Init));
+		CreateTableFunctionInfo generate_series_func_info(generate_series);
+		catalog.AddFunction(context, generate_series_func_info);
+	}
+}

package/src/duckdb/src/function/aggregate/algebraic/ub_duckdb_aggr_algebraic.cpp

@@ -0,0 +1,5 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/function/aggregate/algebraic/avg.cpp>
+#include </Users/carlo/duckdb/src/function/aggregate/algebraic/covar.cpp>
+#include </Users/carlo/duckdb/src/function/aggregate/algebraic/stddev.cpp>
+#include </Users/carlo/duckdb/src/function/aggregate/algebraic/corr.cpp>

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, len);
+				state.value = string_t(ptr, UnsafeNumericCast<int>(len));
 			}
 		}
 	}
@@ -157,7 +157,7 @@ struct FirstVectorFunction {
 			state.value = new Vector(input.GetType());
 			state.value->SetVectorType(VectorType::CONSTANT_VECTOR);
 		}
-		sel_t selv = idx;
+		sel_t selv = UnsafeNumericCast<sel_t>(idx);
 		SelectionVector sel(&selv);
 		VectorOperations::Copy(input, *state.value, sel, 1, 0, 0);
 	}

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

@@ -0,0 +1,3 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/function/aggregate/distributive/count.cpp>
+#include </Users/carlo/duckdb/src/function/aggregate/distributive/first.cpp>

package/src/duckdb/src/function/aggregate/holistic/ub_duckdb_aggr_holistic.cpp

@@ -0,0 +1,5 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/function/aggregate/holistic/quantile.cpp>
+#include </Users/carlo/duckdb/src/function/aggregate/holistic/mode.cpp>
+#include </Users/carlo/duckdb/src/function/aggregate/holistic/approximate_quantile.cpp>
+#include </Users/carlo/duckdb/src/function/aggregate/holistic/reservoir_quantile.cpp>

package/src/duckdb/src/function/aggregate/nested/ub_duckdb_aggr_nested.cpp

@@ -0,0 +1,3 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/function/aggregate/nested/list.cpp>
+#include </Users/carlo/duckdb/src/function/aggregate/nested/histogram.cpp>

package/src/duckdb/src/function/aggregate/regression/ub_duckdb_aggr_regr.cpp

@@ -0,0 +1,8 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/function/aggregate/regression/regr_avg.cpp>
+#include </Users/carlo/duckdb/src/function/aggregate/regression/regr_count.cpp>
+#include </Users/carlo/duckdb/src/function/aggregate/regression/regr_slope.cpp>
+#include </Users/carlo/duckdb/src/function/aggregate/regression/regr_r2.cpp>
+#include </Users/carlo/duckdb/src/function/aggregate/regression/regr_sxx_syy.cpp>
+#include </Users/carlo/duckdb/src/function/aggregate/regression/regr_sxy.cpp>
+#include </Users/carlo/duckdb/src/function/aggregate/regression/regr_intercept.cpp>

package/src/duckdb/src/function/aggregate/sorted_aggregate_function.cpp

@@ -1,3 +1,4 @@
+#include "duckdb/common/numeric_utils.hpp"
 #include "duckdb/common/sort/sort.hpp"
 #include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/common/types/list_segment.hpp"
@@ -519,7 +520,7 @@ struct SortedAggregateFunction {
 				order_state->sel.Initialize(sel_data.data() + order_state->offset);
 				start += order_state->nsel;
 			}
-			sel_data[order_state->offset++] = sidx;
+			sel_data[order_state->offset++] = UnsafeNumericCast<sel_t>(sidx);
 		}
 
 		// Append nonempty slices to the arguments
@@ -603,7 +604,7 @@ struct SortedAggregateFunction {
 			if (unsorted_count < order_bind.threshold) {
 				auto state = sdata[finalized];
 				prefixed.Reset();
-				prefixed.data[0].Reference(Value::USMALLINT(finalized));
+				prefixed.data[0].Reference(Value::USMALLINT(UnsafeNumericCast<uint16_t>(finalized)));
 				state->Finalize(order_bind, prefixed, *local_sort);
 				unsorted_count += state_unprocessed[finalized];
 

package/src/duckdb/src/function/aggregate/ub_duckdb_func_aggr.cpp

@@ -0,0 +1,3 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/function/aggregate/distributive_functions.cpp>
+#include </Users/carlo/duckdb/src/function/aggregate/sorted_aggregate_function.cpp>

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

@@ -46,7 +46,7 @@ static bool ArrayToArrayCast(Vector &source, Vector &result, idx_t count, CastPa
 		// Cant cast between arrays of different sizes
 		auto msg = StringUtil::Format("Cannot cast array of size %u to array of size %u", source_array_size,
 		                              target_array_size);
-		HandleCastError::AssignError(msg, parameters.error_message);
+		HandleCastError::AssignError(msg, parameters);
 		if (!parameters.strict) {
 			// if this was a TRY_CAST, we know every row will fail, so just return null
 			result.SetVectorType(VectorType::CONSTANT_VECTOR);
@@ -169,9 +169,7 @@ static bool ArrayToListCast(Vector &source, Vector &result, idx_t count, CastPar
 
 	// FIXME: dont flatten
 	source.Flatten(count);
-	if (count == 1) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
+
 	auto array_size = ArrayType::GetSize(source.GetType());
 	auto child_count = count * array_size;