duckdb 1.2.1-dev4.0 → 1.2.1-dev8.0

package/src/duckdb/src/function/window/window_boundaries_state.cpp

@@ -180,9 +180,9 @@ struct OperationCompare : public std::function<bool(T, T)> {
 };
 
 template <typename T, typename OP, bool FROM>
-static idx_t FindTypedRangeBound(WindowCursor &over, const idx_t order_begin, const idx_t order_end,
-                                 const WindowBoundary range, WindowInputExpression &boundary, const idx_t chunk_idx,
-                                 const FrameBounds &prev) {
+static idx_t FindTypedRangeBound(WindowCursor &range_lo, WindowCursor &range_hi, const idx_t order_begin,
+                                 const idx_t order_end, const WindowBoundary range, WindowInputExpression &boundary,
+                                 const idx_t chunk_idx, const FrameBounds &prev) {
 	D_ASSERT(!boundary.CellIsNull(chunk_idx));
 	const auto val = boundary.GetCell<T>(chunk_idx);
 
@@ -191,36 +191,43 @@ static idx_t FindTypedRangeBound(WindowCursor &over, const idx_t order_begin, co
 	// Check that the value we are searching for is in range.
 	if (range == WindowBoundary::EXPR_PRECEDING_RANGE) {
 		//	Preceding but value past the current value
-		const auto cur_val = over.GetCell<T>(0, order_end - 1);
+		const auto cur_val = range_hi.GetCell<T>(0, order_end - 1);
 		if (comp(cur_val, val)) {
 			throw OutOfRangeException("Invalid RANGE PRECEDING value");
 		}
 	} else {
 		//	Following but value before the current value
 		D_ASSERT(range == WindowBoundary::EXPR_FOLLOWING_RANGE);
-		const auto cur_val = over.GetCell<T>(0, order_begin);
+		const auto cur_val = range_lo.GetCell<T>(0, order_begin);
 		if (comp(val, cur_val)) {
 			throw OutOfRangeException("Invalid RANGE FOLLOWING value");
 		}
 	}
-
 	//	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.
-	WindowColumnIterator<T> begin(over, order_begin);
-	WindowColumnIterator<T> end(over, order_end);
+	WindowColumnIterator<T> begin(range_lo, order_begin);
+	WindowColumnIterator<T> end(range_hi, order_end);
 	if (prev.start < prev.end) {
 		if (order_begin < prev.start && prev.start < order_end) {
-			const auto first = over.GetCell<T>(0, prev.start);
-			if (!comp(val, first)) {
-				//	prev.first <= val, so we can start further forward
+			const auto first = range_lo.GetCell<T>(0, prev.start);
+			if (FROM && !comp(val, first)) {
+				// If prev.start == val and we are looking for a lower bound, then we are done
+				if (!comp(first, val)) {
+					return prev.start;
+				}
+				//	prev.start <= val, so we can start further forward
 				begin += UnsafeNumericCast<int64_t>(prev.start - order_begin);
 			}
 		}
 		if (order_begin < prev.end && prev.end < order_end) {
-			const auto second = over.GetCell<T>(0, prev.end - 1);
+			const auto second = range_hi.GetCell<T>(0, prev.end - 1);
 			if (!comp(second, val)) {
-				//	val <= prev.second, so we can end further back
+				//  If val == prev.end and we are looking for an upper bound, then we are done
+				if (!FROM && !comp(val, second)) {
+					return prev.end;
+				}
+				//	val <= prev.end, so we can end further back
 				// (prev.second is the largest peer)
 				end -= UnsafeNumericCast<int64_t>(order_end - prev.end - 1);
 			}
@@ -235,52 +242,65 @@ static idx_t FindTypedRangeBound(WindowCursor &over, const idx_t order_begin, co
 }
 
 template <typename OP, bool FROM>
-static idx_t FindRangeBound(WindowCursor &over, const idx_t order_begin, const idx_t order_end,
-                            const WindowBoundary range, WindowInputExpression &boundary, const idx_t chunk_idx,
-                            const FrameBounds &prev) {
+static idx_t FindRangeBound(WindowCursor &range_lo, WindowCursor &range_hi, const idx_t order_begin,
+                            const idx_t order_end, const WindowBoundary range, WindowInputExpression &boundary,
+                            const idx_t chunk_idx, const FrameBounds &prev) {
 	switch (boundary.InternalType()) {
 	case PhysicalType::INT8:
-		return FindTypedRangeBound<int8_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
+		return FindTypedRangeBound<int8_t, OP, FROM>(range_lo, range_hi, order_begin, order_end, range, boundary,
+		                                             chunk_idx, prev);
 	case PhysicalType::INT16:
-		return FindTypedRangeBound<int16_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
+		return FindTypedRangeBound<int16_t, OP, FROM>(range_lo, range_hi, order_begin, order_end, range, boundary,
+		                                              chunk_idx, prev);
 	case PhysicalType::INT32:
-		return FindTypedRangeBound<int32_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
+		return FindTypedRangeBound<int32_t, OP, FROM>(range_lo, range_hi, order_begin, order_end, range, boundary,
+		                                              chunk_idx, prev);
 	case PhysicalType::INT64:
-		return FindTypedRangeBound<int64_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
+		return FindTypedRangeBound<int64_t, OP, FROM>(range_lo, range_hi, order_begin, order_end, range, boundary,
+		                                              chunk_idx, prev);
 	case PhysicalType::UINT8:
-		return FindTypedRangeBound<uint8_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
+		return FindTypedRangeBound<uint8_t, OP, FROM>(range_lo, range_hi, order_begin, order_end, range, boundary,
+		                                              chunk_idx, prev);
 	case PhysicalType::UINT16:
-		return FindTypedRangeBound<uint16_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
+		return FindTypedRangeBound<uint16_t, OP, FROM>(range_lo, range_hi, order_begin, order_end, range, boundary,
+		                                               chunk_idx, prev);
 	case PhysicalType::UINT32:
-		return FindTypedRangeBound<uint32_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
+		return FindTypedRangeBound<uint32_t, OP, FROM>(range_lo, range_hi, order_begin, order_end, range, boundary,
+		                                               chunk_idx, prev);
 	case PhysicalType::UINT64:
-		return FindTypedRangeBound<uint64_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
+		return FindTypedRangeBound<uint64_t, OP, FROM>(range_lo, range_hi, order_begin, order_end, range, boundary,
+		                                               chunk_idx, prev);
 	case PhysicalType::INT128:
-		return FindTypedRangeBound<hugeint_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
+		return FindTypedRangeBound<hugeint_t, OP, FROM>(range_lo, range_hi, order_begin, order_end, range, boundary,
+		                                                chunk_idx, prev);
 	case PhysicalType::UINT128:
-		return FindTypedRangeBound<uhugeint_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx,
-		                                                 prev);
+		return FindTypedRangeBound<uhugeint_t, OP, FROM>(range_lo, range_hi, order_begin, order_end, range, boundary,
+		                                                 chunk_idx, prev);
 	case PhysicalType::FLOAT:
-		return FindTypedRangeBound<float, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
+		return FindTypedRangeBound<float, OP, FROM>(range_lo, range_hi, order_begin, order_end, range, boundary,
+		                                            chunk_idx, prev);
 	case PhysicalType::DOUBLE:
-		return FindTypedRangeBound<double, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
+		return FindTypedRangeBound<double, OP, FROM>(range_lo, range_hi, order_begin, order_end, range, boundary,
+		                                             chunk_idx, prev);
 	case PhysicalType::INTERVAL:
-		return FindTypedRangeBound<interval_t, OP, FROM>(over, order_begin, order_end, range, boundary, chunk_idx,
-		                                                 prev);
+		return FindTypedRangeBound<interval_t, OP, FROM>(range_lo, range_hi, order_begin, order_end, range, boundary,
+		                                                 chunk_idx, prev);
 	default:
 		throw InternalException("Unsupported column type for RANGE");
 	}
 }
 
 template <bool FROM>
-static idx_t FindOrderedRangeBound(WindowCursor &over, const OrderType range_sense, const idx_t order_begin,
-                                   const idx_t order_end, const WindowBoundary range, WindowInputExpression &boundary,
-                                   const idx_t chunk_idx, const FrameBounds &prev) {
+static idx_t FindOrderedRangeBound(WindowCursor &range_lo, WindowCursor &range_hi, const OrderType range_sense,
+                                   const idx_t order_begin, const idx_t order_end, const WindowBoundary range,
+                                   WindowInputExpression &boundary, const idx_t chunk_idx, const FrameBounds &prev) {
 	switch (range_sense) {
 	case OrderType::ASCENDING:
-		return FindRangeBound<LessThan, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
+		return FindRangeBound<LessThan, FROM>(range_lo, range_hi, order_begin, order_end, range, boundary, chunk_idx,
+		                                      prev);
 	case OrderType::DESCENDING:
-		return FindRangeBound<GreaterThan, FROM>(over, order_begin, order_end, range, boundary, chunk_idx, prev);
+		return FindRangeBound<GreaterThan, FROM>(range_lo, range_hi, order_begin, order_end, range, boundary, chunk_idx,
+		                                         prev);
 	default:
 		throw InternalException("Unsupported ORDER BY sense for RANGE");
 	}
@@ -686,19 +706,15 @@ void WindowBoundariesState::ValidEnd(DataChunk &bounds, idx_t row_idx, const idx
 		if (!is_same_partition || is_jump) {
 			// Find valid ordering values for the new partition
 			// so we can exclude NULLs from RANGE expression computations
+			const auto valid_start = valid_begin_data[chunk_idx];
 			valid_end = partition_end_data[chunk_idx];
 
 			if ((valid_start < valid_end) && has_following_range) {
 				// Exclude any trailing NULLs
-				const auto valid_start = valid_begin_data[chunk_idx];
 				if (range->CellIsNull(0, valid_end - 1)) {
 					idx_t n = 1;
 					valid_end = FindPrevStart(order_mask, valid_start, valid_end, n);
 				}
-
-				//	Reset range hints
-				prev.start = valid_start;
-				prev.end = valid_end;
 			}
 		}
 
@@ -718,6 +734,18 @@ void WindowBoundariesState::FrameBegin(DataChunk &bounds, idx_t row_idx, const i
 
 	idx_t window_start = NumericLimits<idx_t>::Maximum();
 
+	//	Reset previous range hints
+	idx_t prev_partition = partition_begin_data[0];
+	prev.start = valid_begin_data[0];
+	prev.end = valid_end_data[0];
+
+	if (has_preceding_range || has_following_range) {
+		if (range_lo.get() != range.get()) {
+			range_lo = range.get();
+			range_hi = range_lo->Copy();
+		}
+	}
+
 	switch (start_boundary) {
 	case WindowBoundary::UNBOUNDED_PRECEDING:
 		bounds.data[FRAME_BEGIN].Reference(bounds.data[PARTITION_BEGIN]);
@@ -766,7 +794,12 @@ void WindowBoundariesState::FrameBegin(DataChunk &bounds, idx_t row_idx, const i
 			} else {
 				const auto valid_start = valid_begin_data[chunk_idx];
 				prev.end = valid_end_data[chunk_idx];
-				window_start = FindOrderedRangeBound<true>(*range, range_sense, valid_start, row_idx + 1,
+				const auto cur_partition = partition_begin_data[chunk_idx];
+				if (cur_partition != prev_partition) {
+					prev.start = valid_start;
+					prev_partition = cur_partition;
+				}
+				window_start = FindOrderedRangeBound<true>(*range_lo, *range_hi, range_sense, valid_start, row_idx + 1,
 				                                           start_boundary, boundary_begin, chunk_idx, prev);
 				prev.start = window_start;
 			}
@@ -780,8 +813,13 @@ void WindowBoundariesState::FrameBegin(DataChunk &bounds, idx_t row_idx, const i
 			} else {
 				const auto valid_end = valid_end_data[chunk_idx];
 				prev.end = valid_end;
-				window_start = FindOrderedRangeBound<true>(*range, range_sense, row_idx, valid_end, start_boundary,
-				                                           boundary_begin, chunk_idx, prev);
+				const auto cur_partition = partition_begin_data[chunk_idx];
+				if (cur_partition != prev_partition) {
+					prev.start = valid_begin_data[chunk_idx];
+					prev_partition = cur_partition;
+				}
+				window_start = FindOrderedRangeBound<true>(*range_lo, *range_hi, range_sense, row_idx, valid_end,
+				                                           start_boundary, boundary_begin, chunk_idx, prev);
 				prev.start = window_start;
 			}
 			frame_begin_data[chunk_idx] = window_start;
@@ -852,6 +890,18 @@ void WindowBoundariesState::FrameEnd(DataChunk &bounds, idx_t row_idx, const idx
 
 	idx_t window_end = NumericLimits<idx_t>::Maximum();
 
+	//	Reset previous range hints
+	idx_t prev_partition = partition_begin_data[0];
+	prev.start = valid_begin_data[0];
+	prev.end = valid_end_data[0];
+
+	if (has_preceding_range || has_following_range) {
+		if (range_lo.get() != range.get()) {
+			range_lo = range.get();
+			range_hi = range_lo->Copy();
+		}
+	}
+
 	switch (end_boundary) {
 	case WindowBoundary::CURRENT_ROW_ROWS:
 		for (idx_t chunk_idx = 0; chunk_idx < count; ++chunk_idx, ++row_idx) {
@@ -901,8 +951,13 @@ void WindowBoundariesState::FrameEnd(DataChunk &bounds, idx_t row_idx, const idx
 			} else {
 				const auto valid_start = valid_begin_data[chunk_idx];
 				prev.start = valid_start;
-				window_end = FindOrderedRangeBound<false>(*range, range_sense, valid_start, row_idx + 1, end_boundary,
-				                                          boundary_end, chunk_idx, prev);
+				const auto cur_partition = partition_begin_data[chunk_idx];
+				if (cur_partition != prev_partition) {
+					prev.end = valid_end;
+					prev_partition = cur_partition;
+				}
+				window_end = FindOrderedRangeBound<false>(*range_lo, *range_hi, range_sense, valid_start, row_idx + 1,
+				                                          end_boundary, boundary_end, chunk_idx, prev);
 				prev.end = window_end;
 			}
 			frame_end_data[chunk_idx] = window_end;
@@ -915,8 +970,13 @@ void WindowBoundariesState::FrameEnd(DataChunk &bounds, idx_t row_idx, const idx
 			} else {
 				const auto valid_end = valid_end_data[chunk_idx];
 				prev.start = valid_begin_data[chunk_idx];
-				window_end = FindOrderedRangeBound<false>(*range, range_sense, row_idx, valid_end, end_boundary,
-				                                          boundary_end, chunk_idx, prev);
+				const auto cur_partition = partition_begin_data[chunk_idx];
+				if (cur_partition != prev_partition) {
+					prev.end = valid_end;
+					prev_partition = cur_partition;
+				}
+				window_end = FindOrderedRangeBound<false>(*range_lo, *range_hi, range_sense, row_idx, valid_end,
+				                                          end_boundary, boundary_end, chunk_idx, prev);
 				prev.end = window_end;
 			}
 			frame_end_data[chunk_idx] = window_end;

package/src/duckdb/src/function/window/window_constant_aggregator.cpp

@@ -18,6 +18,10 @@ public:
 
 	void Finalize(const FrameStats &stats);
 
+	~WindowConstantAggregatorGlobalState() override {
+		statef.Destroy();
+	}
+
 	//! Partition starts
 	vector<idx_t> partition_offsets;
 	//! Reused result state container for the window functions
@@ -304,11 +308,7 @@ void WindowConstantAggregator::Finalize(WindowAggregatorState &gstate, WindowAgg
 	lastate.statef.Combine(gastate.statef);
 	lastate.statef.Destroy();
 
-	//	Last one out turns off the lights!
-	if (++gastate.finalized == gastate.locals) {
-		gastate.statef.Finalize(*gastate.results);
-		gastate.statef.Destroy();
-	}
+	gastate.statef.Finalize(*gastate.results);
 }
 
 unique_ptr<WindowAggregatorState> WindowConstantAggregator::GetLocalState(const WindowAggregatorState &gstate) const {

package/src/duckdb/src/function/window/window_distinct_aggregator.cpp

@@ -190,6 +190,10 @@ class WindowDistinctAggregatorLocalState : public WindowAggregatorLocalState {
 public:
 	explicit WindowDistinctAggregatorLocalState(const WindowDistinctAggregatorGlobalState &aggregator);
 
+	~WindowDistinctAggregatorLocalState() override {
+		statef.Destroy();
+	}
+
 	void Sink(DataChunk &sink_chunk, DataChunk &coll_chunk, idx_t input_idx, optional_ptr<SelectionVector> filter_sel,
 	          idx_t filtered);
 	void Finalize(WindowAggregatorGlobalState &gastate, CollectionPtr collection) override;
@@ -740,6 +744,8 @@ void WindowDistinctAggregatorLocalState::Evaluate(const WindowDistinctAggregator
 
 	//	Finalise the result aggregates and write to the result
 	statef.Finalize(result);
+
+	//	Destruct any non-POD state
 	statef.Destroy();
 }
 

package/src/duckdb/src/include/duckdb/catalog/catalog_entry_retriever.hpp

@@ -56,7 +56,7 @@ public:
 	                                           OnEntryNotFound on_entry_not_found = OnEntryNotFound::THROW_EXCEPTION,
 	                                           QueryErrorContext error_context = QueryErrorContext());
 
-	CatalogSearchPath &GetSearchPath();
+	const CatalogSearchPath &GetSearchPath() const;
 	void SetSearchPath(vector<CatalogSearchEntry> entries);
 
 	void SetCallback(catalog_entry_callback_t callback);

package/src/duckdb/src/include/duckdb/catalog/catalog_search_path.hpp

@@ -48,20 +48,21 @@ public:
 	DUCKDB_API void Set(vector<CatalogSearchEntry> new_paths, CatalogSetPathType set_type);
 	DUCKDB_API void Reset();
 
-	DUCKDB_API const vector<CatalogSearchEntry> &Get();
-	const vector<CatalogSearchEntry> &GetSetPaths() {
+	DUCKDB_API const vector<CatalogSearchEntry> &Get() const;
+	const vector<CatalogSearchEntry> &GetSetPaths() const {
 		return set_paths;
 	}
-	DUCKDB_API const CatalogSearchEntry &GetDefault();
+	DUCKDB_API const CatalogSearchEntry &GetDefault() const;
 	//! FIXME: this method is deprecated
-	DUCKDB_API string GetDefaultSchema(const string &catalog);
-	DUCKDB_API string GetDefaultSchema(ClientContext &context, const string &catalog);
-	DUCKDB_API string GetDefaultCatalog(const string &schema);
+	DUCKDB_API string GetDefaultSchema(const string &catalog) const;
+	DUCKDB_API string GetDefaultSchema(ClientContext &context, const string &catalog) const;
+	DUCKDB_API string GetDefaultCatalog(const string &schema) const;
 
-	DUCKDB_API vector<string> GetSchemasForCatalog(const string &catalog);
-	DUCKDB_API vector<string> GetCatalogsForSchema(const string &schema);
+	DUCKDB_API vector<string> GetSchemasForCatalog(const string &catalog) const;
+	DUCKDB_API vector<string> GetCatalogsForSchema(const string &schema) const;
 
-	DUCKDB_API bool SchemaInSearchPath(ClientContext &context, const string &catalog_name, const string &schema_name);
+	DUCKDB_API bool SchemaInSearchPath(ClientContext &context, const string &catalog_name,
+	                                   const string &schema_name) const;
 
 private:
 	//! Set paths without checking if they exist

package/src/duckdb/src/include/duckdb/common/adbc/adbc-init.hpp

@@ -30,7 +30,7 @@ extern "C" {
 typedef uint8_t AdbcStatusCode;
 
 //! We gotta leak the symbols of the init function
-DUCKDB_API AdbcStatusCode duckdb_adbc_init(int version, void *driver, struct AdbcError *error);
+DUCKDB_C_API AdbcStatusCode duckdb_adbc_init(int version, void *driver, struct AdbcError *error);
 
 #ifdef __cplusplus
 }

package/src/duckdb/src/include/duckdb/common/multi_file_reader.hpp

@@ -168,7 +168,7 @@ struct MultiFileFilterEntry {
 struct MultiFileConstantEntry {
 	MultiFileConstantEntry(idx_t column_id, Value value_p) : column_id(column_id), value(std::move(value_p)) {
 	}
-	//! The column id to apply the constant value to
+	//! The (global) column id to apply the constant value to
 	idx_t column_id;
 	//! The constant value
 	Value value;
@@ -273,7 +273,7 @@ struct MultiFileReader {
 	                                      const string &initial_file, const MultiFileReaderBindData &options,
 	                                      optional_ptr<MultiFileReaderGlobalState> global_state);
 	//! Populated the filter_map
-	DUCKDB_API virtual void CreateFilterMap(const vector<MultiFileReaderColumnDefinition> &global_columns,
+	DUCKDB_API virtual void CreateFilterMap(const vector<ColumnIndex> &global_column_ids,
 	                                        optional_ptr<TableFilterSet> filters, MultiFileReaderData &reader_data,
 	                                        optional_ptr<MultiFileReaderGlobalState> global_state);
 

package/src/duckdb/src/include/duckdb/execution/index/art/iterator.hpp

@@ -90,6 +90,8 @@ private:
 	GateStatus status;
 	//! Depth in a nested leaf.
 	uint8_t nested_depth = 0;
+	//! True, if we entered a nested leaf to retrieve the next node.
+	bool entered_nested_leaf = false;
 
 private:
 	//! Goes to the next leaf in the ART and sets it as last_leaf,

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/base_scanner.hpp

@@ -116,7 +116,7 @@ class BaseScanner {
 public:
 	explicit BaseScanner(shared_ptr<CSVBufferManager> buffer_manager, shared_ptr<CSVStateMachine> state_machine,
 	                     shared_ptr<CSVErrorHandler> error_handler, bool sniffing = false,
-	                     shared_ptr<CSVFileScan> csv_file_scan = nullptr, CSVIterator iterator = {});
+	                     shared_ptr<CSVFileScan> csv_file_scan = nullptr, const CSVIterator &iterator = {});
 
 	virtual ~BaseScanner() = default;
 

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_buffer.hpp

@@ -45,14 +45,15 @@ class CSVBuffer {
 public:
 	//! Constructor for Initial Buffer
 	CSVBuffer(ClientContext &context, idx_t buffer_size_p, CSVFileHandle &file_handle,
-	          idx_t &global_csv_current_position, idx_t file_number);
+	          const idx_t &global_csv_current_position, idx_t file_number);
 
 	//! Constructor for `Next()` Buffers
 	CSVBuffer(CSVFileHandle &file_handle, ClientContext &context, idx_t buffer_size, idx_t global_csv_current_position,
 	          idx_t file_number_p, idx_t buffer_idx);
 
 	//! Creates a new buffer with the next part of the CSV File
-	shared_ptr<CSVBuffer> Next(CSVFileHandle &file_handle, idx_t buffer_size, idx_t file_number, bool &has_seaked);
+	shared_ptr<CSVBuffer> Next(CSVFileHandle &file_handle, idx_t buffer_size, idx_t file_number,
+	                           bool &has_seaked) const;
 
 	//! Gets the buffer actual size
 	idx_t GetBufferSize() const;
@@ -67,12 +68,12 @@ public:
 	//! Wrapper for the Pin Function, if it can seek, it means that the buffer might have been destroyed, hence we must
 	//! Scan it from the disk file again.
 	shared_ptr<CSVBufferHandle> Pin(CSVFileHandle &file_handle, bool &has_seeked);
-	//! Wrapper for the unpin
+	//! Wrapper for unpin
 	void Unpin();
 	char *Ptr() {
 		return char_ptr_cast(handle.Ptr());
 	}
-	bool IsUnloaded() {
+	bool IsUnloaded() const {
 		return block->IsUnloaded();
 	}
 

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_option.hpp

@@ -30,7 +30,7 @@ struct CSVOption { // NOLINT: work-around bug in clang-tidy
 public:
 	CSVOption(T value_p) : value(value_p) { // NOLINT: allow implicit conversion from value
 	}
-	CSVOption(T value_p, bool set_by_user_p) : value(value_p), set_by_user(set_by_user_p) {
+	CSVOption(T value_p, bool set_by_user_p) : set_by_user(set_by_user_p), value(value_p) {
 	}
 
 	CSVOption() {};

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_schema.hpp

@@ -14,7 +14,7 @@
 namespace duckdb {
 //! Basic CSV Column Info
 struct CSVColumnInfo {
-	CSVColumnInfo(string &name_p, LogicalType &type_p) : name(name_p), type(type_p) {
+	CSVColumnInfo(const string &name_p, const LogicalType &type_p) : name(name_p), type(type_p) {
 	}
 	string name;
 	LogicalType type;
@@ -25,7 +25,7 @@ struct CSVSchema {
 	explicit CSVSchema(const bool empty = false) : empty(empty) {
 	}
 
-	CSVSchema(vector<string> &names, vector<LogicalType> &types, const string &file_path, idx_t rows_read,
+	CSVSchema(const vector<string> &names, const vector<LogicalType> &types, const string &file_path, idx_t rows_read,
 	          const bool empty = false);
 
 	//! Initializes the schema based on names and types

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/encode/csv_encoder.hpp

@@ -46,7 +46,7 @@ private:
 class CSVEncoder {
 public:
 	//! Constructor, basically takes an encoding and the output buffer size
-	CSVEncoder(DBConfig &config, const string &encoding_name, idx_t buffer_size);
+	CSVEncoder(const DBConfig &config, const string &encoding_name, idx_t buffer_size);
 	//! Main encode function, it reads the file into an encoded buffer and converts it to the output buffer
 	idx_t Encode(FileHandle &file_handle_input, char *output_buffer, const idx_t decoded_buffer_size);
 	string encoding_name;

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp

@@ -222,7 +222,7 @@ private:
 	//! ------------------ Type Refinement ------------------ //
 	//! ------------------------------------------------------//
 	void RefineTypes();
-	bool TryCastVector(Vector &parse_chunk_col, idx_t size, const LogicalType &sql_type);
+	bool TryCastVector(Vector &parse_chunk_col, idx_t size, const LogicalType &sql_type) const;
 	vector<LogicalType> detected_types;
 	//! If when finding a SQLNULL type in type detection we default it to varchar
 	const bool default_null_to_varchar;

package/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/string_value_scanner.hpp

@@ -121,8 +121,8 @@ private:
 };
 
 struct ParseTypeInfo {
-	ParseTypeInfo() {};
-	ParseTypeInfo(const LogicalType &type, bool validate_utf_8_p) : validate_utf8(validate_utf_8_p) {
+	ParseTypeInfo() : validate_utf8(false), type_id(), internal_type(), scale(0), width(0) {};
+	ParseTypeInfo(const LogicalType &type, const bool validate_utf_8_p) : validate_utf8(validate_utf_8_p) {
 		type_id = type.id();
 		internal_type = type.InternalType();
 		if (type.id() == LogicalTypeId::DECIMAL) {

package/src/duckdb/src/include/duckdb/execution/operator/helper/physical_streaming_sample.hpp

@@ -19,12 +19,10 @@ public:
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::STREAMING_SAMPLE;
 
 public:
-	PhysicalStreamingSample(vector<LogicalType> types, SampleMethod method, double percentage, int64_t seed,
-	                        idx_t estimated_cardinality);
+	PhysicalStreamingSample(vector<LogicalType> types, unique_ptr<SampleOptions> options, idx_t estimated_cardinality);
 
-	SampleMethod method;
+	unique_ptr<SampleOptions> sample_options;
 	double percentage;
-	int64_t seed;
 
 public:
 	// Operator interface
@@ -32,9 +30,7 @@ public:
 	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
 	                           GlobalOperatorState &gstate, OperatorState &state) const override;
 
-	bool ParallelOperator() const override {
-		return true;
-	}
+	bool ParallelOperator() const override;
 
 	InsertionOrderPreservingMap<string> ParamsToString() const override;
 

package/src/duckdb/src/include/duckdb/execution/reservoir_sample.hpp

@@ -201,7 +201,8 @@ public:
 	void ConvertToReservoirSample();
 
 	//! Get the capactiy of the data chunk reserved for storing samples
-	idx_t GetReservoirChunkCapacity() const;
+	template <typename T>
+	T GetReservoirChunkCapacity() const;
 
 	//! If for_serialization=true then the sample_chunk is not padded with extra spaces for
 	//! future sampling values

package/src/duckdb/src/include/duckdb/function/lambda_functions.hpp

@@ -17,7 +17,7 @@
 
 namespace duckdb {
 
-struct ListLambdaBindData : public FunctionData {
+struct ListLambdaBindData final : public FunctionData {
 public:
 	ListLambdaBindData(const LogicalType &return_type, unique_ptr<Expression> lambda_expr, const bool has_index = false)
 	    : return_type(return_type), lambda_expr(std::move(lambda_expr)), has_index(has_index) {};
@@ -30,8 +30,16 @@ public:
 	bool has_index;
 
 public:
-	bool Equals(const FunctionData &other_p) const override;
-	unique_ptr<FunctionData> Copy() const override;
+	unique_ptr<FunctionData> Copy() const override {
+		auto lambda_expr_copy = lambda_expr ? lambda_expr->Copy() : nullptr;
+		return make_uniq<ListLambdaBindData>(return_type, std::move(lambda_expr_copy), has_index);
+	}
+
+	bool Equals(const FunctionData &other_p) const override {
+		auto &other = other_p.Cast<ListLambdaBindData>();
+		return Expression::Equals(lambda_expr, other.lambda_expr) && return_type == other.return_type &&
+		       has_index == other.has_index;
+	}
 
 	//! Serializes a lambda function's bind data
 	static void Serialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,

package/src/duckdb/src/include/duckdb/function/window/window_boundaries_state.hpp

@@ -148,6 +148,10 @@ struct WindowBoundariesState {
 	idx_t valid_end = 0;
 
 	FrameBounds prev;
+
+	// Extra range cursor
+	optional_ptr<WindowCursor> range_lo;
+	unique_ptr<WindowCursor> range_hi;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/main/client_context_state.hpp

@@ -80,6 +80,10 @@ public:
 	}
 	virtual void WriteProfilingInformation(std::ostream &ss) {
 	}
+	virtual void OnTaskStart(ClientContext &context) {
+	}
+	virtual void OnTaskStop(ClientContext &context) {
+	}
 
 public:
 	template <class TARGET>