duckdb 0.10.3-dev0.0 → 0.10.3-dev6.0

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

@@ -9,11 +9,12 @@
 
 namespace duckdb {
 
-template <class DATA_TYPE, class ALLOCATOR_TYPE = std::default_delete<DATA_TYPE>, bool SAFE = true>
-class unique_ptr : public std::unique_ptr<DATA_TYPE, ALLOCATOR_TYPE> { // NOLINT: naming
+template <class DATA_TYPE, class DELETER = std::default_delete<DATA_TYPE>, bool SAFE = true>
+class unique_ptr : public std::unique_ptr<DATA_TYPE, DELETER> { // NOLINT: naming
 public:
-	using original = std::unique_ptr<DATA_TYPE, ALLOCATOR_TYPE>;
+	using original = std::unique_ptr<DATA_TYPE, DELETER>;
 	using original::original; // NOLINT
+	using pointer = typename original::pointer;
 
 private:
 	static inline void AssertNotNull(const bool null) {
@@ -53,9 +54,9 @@ public:
 	}
 };
 
-template <class DATA_TYPE, class ALLOCATOR_TYPE, bool SAFE>
-class unique_ptr<DATA_TYPE[], ALLOCATOR_TYPE, SAFE>
-    : public std::unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE[]>> {
+// FIXME: DELETER is defined, but we use std::default_delete???
+template <class DATA_TYPE, class DELETER, bool SAFE>
+class unique_ptr<DATA_TYPE[], DELETER, SAFE> : public std::unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE[]>> {
 public:
 	using original = std::unique_ptr<DATA_TYPE[], std::default_delete<DATA_TYPE[]>>;
 	using original::original;

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

@@ -100,6 +100,17 @@ public:
 		}
 		return get<SAFE>(original::size() - 1);
 	}
+
+	void unsafe_erase_at(idx_t idx) { // NOLINT: not using camelcase on purpose here
+		original::erase(original::begin() + static_cast<typename original::iterator::difference_type>(idx));
+	}
+
+	void erase_at(idx_t idx) { // NOLINT: not using camelcase on purpose here
+		if (MemorySafety<SAFE>::ENABLED && idx > original::size()) {
+			throw InternalException("Can't remove offset %d from vector of size %d", idx, original::size());
+		}
+		unsafe_erase_at(idx);
+	}
 };
 
 template <typename T>

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

@@ -13,7 +13,7 @@
 namespace duckdb {
 
 //! The default standard vector size
-#define DEFAULT_STANDARD_VECTOR_SIZE 2048
+#define DEFAULT_STANDARD_VECTOR_SIZE 2048U
 
 //! The vector size used in the execution engine
 #ifndef STANDARD_VECTOR_SIZE

package/src/duckdb/src/include/duckdb/common/weak_ptr.ipp

@@ -0,0 +1,117 @@
+namespace duckdb {
+
+template <typename T, bool SAFE>
+class weak_ptr { // NOLINT: invalid case style
+public:
+	using original = std::weak_ptr<T>;
+	using element_type = typename original::element_type;
+
+private:
+	template <class U, bool SAFE_P>
+	friend class shared_ptr;
+
+private:
+	original internal;
+
+public:
+	// Constructors
+	weak_ptr() : internal() {
+	}
+
+	// NOLINTBEGIN
+	template <class U, typename std::enable_if<compatible_with_t<U, T>::value, int>::type = 0>
+	weak_ptr(shared_ptr<U, SAFE> const &ptr) noexcept : internal(ptr.internal) {
+	}
+	weak_ptr(weak_ptr const &other) noexcept : internal(other.internal) {
+	}
+	template <class U, typename std::enable_if<compatible_with_t<U, T>::value, int>::type = 0>
+	weak_ptr(weak_ptr<U> const &ptr) noexcept : internal(ptr.internal) {
+	}
+#ifdef DUCKDB_CLANG_TIDY
+	[[clang::reinitializes]]
+#endif
+	weak_ptr(weak_ptr &&ptr) noexcept
+	    : internal(std::move(ptr.internal)) {
+	}
+	template <class U, typename std::enable_if<compatible_with_t<U, T>::value, int>::type = 0>
+#ifdef DUCKDB_CLANG_TIDY
+	[[clang::reinitializes]]
+#endif
+	weak_ptr(weak_ptr<U> &&ptr) noexcept
+	    : internal(std::move(ptr.internal)) {
+	}
+	// NOLINTEND
+	// Destructor
+	~weak_ptr() = default;
+
+	// Assignment operators
+	weak_ptr &operator=(const weak_ptr &other) {
+		if (this == &other) {
+			return *this;
+		}
+		internal = other.internal;
+		return *this;
+	}
+
+	template <class U, typename std::enable_if<compatible_with_t<U, T>::value, int>::type = 0>
+	weak_ptr &operator=(const shared_ptr<U, SAFE> &ptr) {
+		internal = ptr.internal;
+		return *this;
+	}
+
+	// Modifiers
+#ifdef DUCKDB_CLANG_TIDY
+	// This is necessary to tell clang-tidy that it reinitializes the variable after a move
+	[[clang::reinitializes]]
+#endif
+	void
+	reset() { // NOLINT: invalid case style
+		internal.reset();
+	}
+
+	// Observers
+	long use_count() const { // NOLINT: invalid case style
+		return internal.use_count();
+	}
+
+	bool expired() const { // NOLINT: invalid case style
+		return internal.expired();
+	}
+
+	shared_ptr<T, SAFE> lock() const { // NOLINT: invalid case style
+		return shared_ptr<T, SAFE>(internal.lock());
+	}
+
+	// Relational operators
+	template <typename U>
+	bool operator==(const weak_ptr<U> &other) const noexcept {
+		return internal == other.internal;
+	}
+
+	template <typename U>
+	bool operator!=(const weak_ptr<U> &other) const noexcept {
+		return internal != other.internal;
+	}
+
+	template <typename U>
+	bool operator<(const weak_ptr<U> &other) const noexcept {
+		return internal < other.internal;
+	}
+
+	template <typename U>
+	bool operator<=(const weak_ptr<U> &other) const noexcept {
+		return internal <= other.internal;
+	}
+
+	template <typename U>
+	bool operator>(const weak_ptr<U> &other) const noexcept {
+		return internal > other.internal;
+	}
+
+	template <typename U>
+	bool operator>=(const weak_ptr<U> &other) const noexcept {
+		return internal >= other.internal;
+	}
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/core_functions/aggregate/sum_helpers.hpp

@@ -61,7 +61,7 @@ struct RegularAdd {
 
 	template <class STATE, class T>
 	static void AddConstant(STATE &state, T input, idx_t count) {
-		state.value += input * count;
+		state.value += input * int64_t(count);
 	}
 };
 
@@ -73,7 +73,7 @@ struct HugeintAdd {
 
 	template <class STATE, class T>
 	static void AddConstant(STATE &state, T input, idx_t count) {
-		AddNumber(state, Hugeint::Multiply(input, count));
+		AddNumber(state, Hugeint::Multiply(input, UnsafeNumericCast<int64_t>(count)));
 	}
 };
 
@@ -135,7 +135,7 @@ struct AddToHugeint {
 					AddValue(state.value, uint64_t(input), input >= 0);
 				}
 			} else {
-				hugeint_t addition = hugeint_t(input) * count;
+				hugeint_t addition = hugeint_t(input) * Hugeint::Convert(count);
 				state.value += addition;
 			}
 		}

package/src/duckdb/src/include/duckdb/core_functions/scalar/date_functions.hpp

@@ -435,6 +435,15 @@ struct TimezoneMinuteFun {
 	static ScalarFunctionSet GetFunctions();
 };
 
+struct TimeTZSortKeyFun {
+	static constexpr const char *Name = "timetz_byte_comparable";
+	static constexpr const char *Parameters = "time_tz";
+	static constexpr const char *Description = "Converts a TIME WITH TIME ZONE to an integer sort key";
+	static constexpr const char *Example = "timetz_byte_comparable('18:18:16.21-07:00'::TIME_TZ)";
+
+	static ScalarFunction GetFunction();
+};
+
 struct ToCenturiesFun {
 	static constexpr const char *Name = "to_centuries";
 	static constexpr const char *Parameters = "integer";
@@ -516,6 +525,15 @@ struct ToMonthsFun {
 	static ScalarFunction GetFunction();
 };
 
+struct ToQuartersFun {
+	static constexpr const char *Name = "to_quarters";
+	static constexpr const char *Parameters = "integer";
+	static constexpr const char *Description = "Construct a quarter interval";
+	static constexpr const char *Example = "to_quarters(5)";
+
+	static ScalarFunction GetFunction();
+};
+
 struct ToSecondsFun {
 	static constexpr const char *Name = "to_seconds";
 	static constexpr const char *Parameters = "double";

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

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/planner/expression/list.hpp"
+#include "duckdb/planner/table_filter.hpp"
 
 #include <random>
 namespace duckdb {

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

@@ -20,7 +20,7 @@ class ExecutionContext;
 
 //! ExpressionExecutor is responsible for executing a set of expressions and storing the result in a data chunk
 class ExpressionExecutor {
-	friend class Index;
+	friend class BoundIndex;
 	friend class CreateIndexLocalSinkState;
 
 public:

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

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "duckdb/storage/index.hpp"
+#include "duckdb/execution/index/bound_index.hpp"
 #include "duckdb/execution/index/art/node.hpp"
 #include "duckdb/common/array.hpp"
 
@@ -31,7 +31,7 @@ struct ARTFlags {
 	vector<idx_t> merge_buffer_counts;
 };
 
-class ART : public Index {
+class ART : public BoundIndex {
 public:
 	// Index type name for the ART
 	static constexpr const char *TYPE_NAME = "ART";
@@ -64,7 +64,7 @@ public:
 
 public:
 	//! Create a index instance of this type
-	static unique_ptr<Index> Create(CreateIndexInput &input) {
+	static unique_ptr<BoundIndex> Create(CreateIndexInput &input) {
 		auto art = make_uniq<ART>(input.name, input.constraint_type, input.column_ids, input.table_io_manager,
 		                          input.unbound_expressions, input.db, nullptr, input.storage_info);
 		return std::move(art);
@@ -96,7 +96,7 @@ public:
 
 	//! Merge another index into this index. The lock obtained from InitializeLock must be held, and the other
 	//! index must also be locked during the merge
-	bool MergeIndexes(IndexLock &state, Index &other_index) override;
+	bool MergeIndexes(IndexLock &state, BoundIndex &other_index) override;
 
 	//! Traverses an ART and vacuums the qualifying nodes. The lock obtained from InitializeLock must be held
 	void Vacuum(IndexLock &state) override;

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

@@ -117,7 +117,7 @@ public:
 	}
 	//! Set the row ID (8th to 63rd bit)
 	inline void SetRowId(const row_t row_id) {
-		Set((Get() & AND_METADATA) | row_id);
+		Set((Get() & AND_METADATA) | UnsafeNumericCast<idx_t>(row_id));
 	}
 
 	//! Returns the type of the node, which is held in the metadata

package/src/duckdb/src/include/duckdb/execution/index/bound_index.hpp

@@ -0,0 +1,145 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/index.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/enums/index_constraint_type.hpp"
+#include "duckdb/common/types/constraint_conflict_info.hpp"
+#include "duckdb/common/types/data_chunk.hpp"
+#include "duckdb/common/unordered_set.hpp"
+#include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/parser/parsed_expression.hpp"
+#include "duckdb/planner/expression.hpp"
+#include "duckdb/storage/table_storage_info.hpp"
+#include "duckdb/storage/index.hpp"
+
+namespace duckdb {
+
+class ClientContext;
+class TableIOManager;
+class Transaction;
+class ConflictManager;
+
+struct IndexLock;
+struct IndexScanState;
+
+//! The index is an abstract base class that serves as the basis for indexes
+class BoundIndex : public Index {
+public:
+	BoundIndex(const string &name, const string &index_type, IndexConstraintType index_constraint_type,
+	           const vector<column_t> &column_ids, TableIOManager &table_io_manager,
+	           const vector<unique_ptr<Expression>> &unbound_expressions, AttachedDatabase &db);
+
+	//! The physical types stored in the index
+	vector<PhysicalType> types;
+	//! The logical types of the expressions
+	vector<LogicalType> logical_types;
+
+	//! The name of the index
+	string name;
+	//! The index type (ART, B+-tree, Skip-List, ...)
+	string index_type;
+	//! The index constraint type
+	IndexConstraintType index_constraint_type;
+
+public:
+	bool IsBound() const override {
+		return true;
+	}
+
+	const string &GetIndexType() const override {
+		return index_type;
+	}
+
+	const string &GetIndexName() const override {
+		return name;
+	}
+
+	IndexConstraintType GetConstraintType() const override {
+		return index_constraint_type;
+	}
+
+public: // Index interface
+	//! Obtain a lock on the index
+	void InitializeLock(IndexLock &state);
+	//! Called when data is appended to the index. The lock obtained from InitializeLock must be held
+	virtual ErrorData Append(IndexLock &state, DataChunk &entries, Vector &row_identifiers) = 0;
+	//! Obtains a lock and calls Append while holding that lock
+	ErrorData Append(DataChunk &entries, Vector &row_identifiers);
+	//! Verify that data can be appended to the index without a constraint violation
+	virtual void VerifyAppend(DataChunk &chunk) = 0;
+	//! Verify that data can be appended to the index without a constraint violation using the conflict manager
+	virtual void VerifyAppend(DataChunk &chunk, ConflictManager &conflict_manager) = 0;
+	//! Performs constraint checking for a chunk of input data
+	virtual void CheckConstraintsForChunk(DataChunk &input, ConflictManager &conflict_manager) = 0;
+
+	//! Deletes all data from the index. The lock obtained from InitializeLock must be held
+	virtual void CommitDrop(IndexLock &index_lock) = 0;
+	//! Deletes all data from the index
+	void CommitDrop() override;
+	//! Delete a chunk of entries from the index. The lock obtained from InitializeLock must be held
+	virtual void Delete(IndexLock &state, DataChunk &entries, Vector &row_identifiers) = 0;
+	//! Obtains a lock and calls Delete while holding that lock
+	void Delete(DataChunk &entries, Vector &row_identifiers);
+
+	//! Insert a chunk of entries into the index
+	virtual ErrorData Insert(IndexLock &lock, DataChunk &input, Vector &row_identifiers) = 0;
+
+	//! Merge another index into this index. The lock obtained from InitializeLock must be held, and the other
+	//! index must also be locked during the merge
+	virtual bool MergeIndexes(IndexLock &state, BoundIndex &other_index) = 0;
+	//! Obtains a lock and calls MergeIndexes while holding that lock
+	bool MergeIndexes(BoundIndex &other_index);
+
+	//! Traverses an ART and vacuums the qualifying nodes. The lock obtained from InitializeLock must be held
+	virtual void Vacuum(IndexLock &state) = 0;
+	//! Obtains a lock and calls Vacuum while holding that lock
+	void Vacuum();
+
+	//! Returns the in-memory usage of the index. The lock obtained from InitializeLock must be held
+	virtual idx_t GetInMemorySize(IndexLock &state) = 0;
+	//! Returns the in-memory usage of the index
+	idx_t GetInMemorySize();
+
+	//! Returns the string representation of an index, or only traverses and verifies the index
+	virtual string VerifyAndToString(IndexLock &state, const bool only_verify) = 0;
+	//! Obtains a lock and calls VerifyAndToString while holding that lock
+	string VerifyAndToString(const bool only_verify);
+
+	//! Returns true if the index is affected by updates on the specified column IDs, and false otherwise
+	bool IndexIsUpdated(const vector<PhysicalIndex> &column_ids) const;
+
+	//! Returns all index storage information for serialization
+	virtual IndexStorageInfo GetStorageInfo(const bool get_buffers);
+
+	//! Execute the index expressions on an input chunk
+	void ExecuteExpressions(DataChunk &input, DataChunk &result);
+	static string AppendRowError(DataChunk &input, idx_t index);
+
+	//! Throw a constraint violation exception
+	virtual string GetConstraintViolationMessage(VerifyExistenceType verify_type, idx_t failed_index,
+	                                             DataChunk &input) = 0;
+
+	vector<unique_ptr<Expression>> unbound_expressions;
+
+protected:
+	//! Lock used for any changes to the index
+	mutex lock;
+
+	//! Bound expressions used during expression execution
+	vector<unique_ptr<Expression>> bound_expressions;
+
+private:
+	//! Expression executor to execute the index expressions
+	ExpressionExecutor executor;
+
+	//! Bind the unbound expressions of the index
+	unique_ptr<Expression> BindExpression(unique_ptr<Expression> expr);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/index/index_type.hpp

@@ -17,7 +17,7 @@
 
 namespace duckdb {
 
-class Index;
+class BoundIndex;
 enum class IndexConstraintType : uint8_t;
 class Expression;
 class TableIOManager;
@@ -43,7 +43,7 @@ struct CreateIndexInput {
 	      options(options) {};
 };
 
-typedef unique_ptr<Index> (*index_create_function_t)(CreateIndexInput &input);
+typedef unique_ptr<BoundIndex> (*index_create_function_t)(CreateIndexInput &input);
 //! A index "type"
 class IndexType {
 public:

package/src/duckdb/src/include/duckdb/execution/index/unbound_index.hpp

@@ -0,0 +1,63 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/index/unbound_index.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/storage/index.hpp"
+#include "duckdb/parser/parsed_data/create_index_info.hpp"
+
+namespace duckdb {
+
+class UnboundIndex final : public Index {
+private:
+	// The create info of the index
+	unique_ptr<CreateInfo> create_info;
+
+	// The serialized storage info of the index
+	IndexStorageInfo storage_info;
+
+public:
+	UnboundIndex(unique_ptr<CreateInfo> create_info, IndexStorageInfo storage_info, TableIOManager &table_io_manager,
+	             AttachedDatabase &db);
+
+	bool IsBound() const override {
+		return false;
+	}
+
+	const string &GetIndexType() const override {
+		return GetCreateInfo().index_type;
+	}
+
+	const string &GetIndexName() const override {
+		return GetCreateInfo().index_name;
+	}
+
+	IndexConstraintType GetConstraintType() const override {
+		return GetCreateInfo().constraint_type;
+	}
+
+	const CreateIndexInfo &GetCreateInfo() const {
+		return create_info->Cast<CreateIndexInfo>();
+	}
+
+	const IndexStorageInfo &GetStorageInfo() const {
+		return storage_info;
+	}
+
+	const vector<unique_ptr<ParsedExpression>> &GetParsedExpressions() const {
+		return GetCreateInfo().parsed_expressions;
+	}
+
+	const string &GetTableName() const {
+		return GetCreateInfo().table;
+	}
+
+	void CommitDrop() override;
+};
+
+} // namespace duckdb

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

@@ -349,7 +349,7 @@ idx_t MergeSortTree<E, O, CMP, F, C>::SelectNth(const SubFrames &frames, idx_t n
 	// 	The first level contains a single run,
 	//	so the only thing we need is any cascading pointers
 	auto level_no = tree.size() - 2;
-	auto level_width = 1;
+	idx_t level_width = 1;
 	for (idx_t i = 0; i < level_no; ++i) {
 		level_width *= FANOUT;
 	}
@@ -367,9 +367,11 @@ idx_t MergeSortTree<E, O, CMP, F, C>::SelectNth(const SubFrames &frames, idx_t n
 		for (idx_t f = 0; f < frames.size(); ++f) {
 			const auto &frame = frames[f];
 			auto &cascade_idx = cascades[f];
-			const auto lower_idx = std::lower_bound(level.begin(), level.end(), frame.start) - level.begin();
+			const auto lower_idx =
+			    UnsafeNumericCast<idx_t>(std::lower_bound(level.begin(), level.end(), frame.start) - level.begin());
 			cascade_idx.first = lower_idx / CASCADING * FANOUT;
-			const auto upper_idx = std::lower_bound(level.begin(), level.end(), frame.end) - level.begin();
+			const auto upper_idx =
+			    UnsafeNumericCast<idx_t>(std::lower_bound(level.begin(), level.end(), frame.end) - level.begin());
 			cascade_idx.second = upper_idx / CASCADING * FANOUT;
 		}
 
@@ -390,11 +392,13 @@ idx_t MergeSortTree<E, O, CMP, F, C>::SelectNth(const SubFrames &frames, idx_t n
 
 					const auto lower_begin = level_data + level_cascades[cascade_idx.first];
 					const auto lower_end = level_data + level_cascades[cascade_idx.first + FANOUT];
-					match.first = std::lower_bound(lower_begin, lower_end, frame.start) - level_data;
+					match.first =
+					    UnsafeNumericCast<idx_t>(std::lower_bound(lower_begin, lower_end, frame.start) - level_data);
 
 					const auto upper_begin = level_data + level_cascades[cascade_idx.second];
 					const auto upper_end = level_data + level_cascades[cascade_idx.second + FANOUT];
-					match.second = std::lower_bound(upper_begin, upper_end, frame.end) - level_data;
+					match.second =
+					    UnsafeNumericCast<idx_t>(std::lower_bound(upper_begin, upper_end, frame.end) - level_data);
 
 					matched += idx_t(match.second - match.first);
 				}
@@ -426,8 +430,8 @@ idx_t MergeSortTree<E, O, CMP, F, C>::SelectNth(const SubFrames &frames, idx_t n
 	//	Continue with the uncascaded levels (except the first)
 	for (; level_no > 0; --level_no) {
 		const auto &level = tree[level_no].first;
-		auto range_begin = level.begin() + result * level_width;
-		auto range_end = range_begin + level_width;
+		auto range_begin = level.begin() + UnsafeNumericCast<int64_t>(result * level_width);
+		auto range_end = range_begin + UnsafeNumericCast<int64_t>(level_width);
 		while (range_end < level.end()) {
 			idx_t matched = 0;
 			for (idx_t f = 0; f < frames.size(); ++f) {
@@ -443,7 +447,7 @@ idx_t MergeSortTree<E, O, CMP, F, C>::SelectNth(const SubFrames &frames, idx_t n
 			}
 			//	Not enough in this child, so move right
 			range_begin = range_end;
-			range_end += level_width;
+			range_end += UnsafeNumericCast<int64_t>(level_width);
 			++result;
 			n -= matched;
 		}
@@ -511,8 +515,8 @@ void MergeSortTree<E, O, CMP, F, C>::AggregateLowerBound(const idx_t lower, cons
 			entry.first = run_idx.first * level_width;
 			entry.second = std::min(entry.first + level_width, static_cast<idx_t>(tree[0].first.size()));
 			auto *level_data = tree[level].first.data();
-			idx_t entry_idx =
-			    std::lower_bound(level_data + entry.first, level_data + entry.second, needle) - level_data;
+			auto entry_idx = NumericCast<idx_t>(
+			    std::lower_bound(level_data + entry.first, level_data + entry.second, needle) - level_data);
 			cascading_idx.first = cascading_idx.second =
 			    (entry_idx / CASCADING + 2 * (entry.first / level_width)) * FANOUT;
 
@@ -541,7 +545,7 @@ void MergeSortTree<E, O, CMP, F, C>::AggregateLowerBound(const idx_t lower, cons
 				const auto run_pos = std::lower_bound(search_begin, search_end, needle) - level_data;
 				// Compute runBegin and pass it to our callback
 				const auto run_begin = curr.first - level_width;
-				aggregate(level, run_begin, run_pos);
+				aggregate(level, run_begin, NumericCast<idx_t>(run_pos));
 				// Update state for next round
 				curr.first -= level_width;
 				--cascading_idx.first;
@@ -550,7 +554,7 @@ void MergeSortTree<E, O, CMP, F, C>::AggregateLowerBound(const idx_t lower, cons
 			if (curr.first != lower) {
 				const auto *search_begin = level_data + cascading_idcs[cascading_idx.first];
 				const auto *search_end = level_data + cascading_idcs[cascading_idx.first + FANOUT];
-				auto idx = std::lower_bound(search_begin, search_end, needle) - level_data;
+				auto idx = NumericCast<idx_t>(std::lower_bound(search_begin, search_end, needle) - level_data);
 				cascading_idx.first = (idx / CASCADING + 2 * (lower / level_width)) * FANOUT;
 			}
 
@@ -563,7 +567,7 @@ void MergeSortTree<E, O, CMP, F, C>::AggregateLowerBound(const idx_t lower, cons
 				const auto run_pos = std::lower_bound(search_begin, search_end, needle) - level_data;
 				// Compute runBegin and pass it to our callback
 				const auto run_begin = curr.second;
-				aggregate(level, run_begin, run_pos);
+				aggregate(level, run_begin, NumericCast<idx_t>(run_pos));
 				// Update state for next round
 				curr.second += level_width;
 				++cascading_idx.second;
@@ -572,7 +576,7 @@ void MergeSortTree<E, O, CMP, F, C>::AggregateLowerBound(const idx_t lower, cons
 			if (curr.second != upper) {
 				const auto *search_begin = level_data + cascading_idcs[cascading_idx.second];
 				const auto *search_end = level_data + cascading_idcs[cascading_idx.second + FANOUT];
-				auto idx = std::lower_bound(search_begin, search_end, needle) - level_data;
+				auto idx = NumericCast<idx_t>(std::lower_bound(search_begin, search_end, needle) - level_data);
 				cascading_idx.second = (idx / CASCADING + 2 * (upper / level_width)) * FANOUT;
 			}
 		} while (level >= LowestCascadingLevel());
@@ -587,8 +591,9 @@ void MergeSortTree<E, O, CMP, F, C>::AggregateLowerBound(const idx_t lower, cons
 			while (curr.first - lower >= level_width) {
 				const auto *search_end = level_data + curr.first;
 				const auto *search_begin = search_end - level_width;
-				const auto run_pos = std::lower_bound(search_begin, search_end, needle) - level_data;
-				const auto run_begin = search_begin - level_data;
+				const auto run_pos =
+				    NumericCast<idx_t>(std::lower_bound(search_begin, search_end, needle) - level_data);
+				const auto run_begin = NumericCast<idx_t>(search_begin - level_data);
 				aggregate(level, run_begin, run_pos);
 				curr.first -= level_width;
 			}
@@ -596,8 +601,9 @@ void MergeSortTree<E, O, CMP, F, C>::AggregateLowerBound(const idx_t lower, cons
 			while (upper - curr.second >= level_width) {
 				const auto *search_begin = level_data + curr.second;
 				const auto *search_end = search_begin + level_width;
-				const auto run_pos = std::lower_bound(search_begin, search_end, needle) - level_data;
-				const auto run_begin = search_begin - level_data;
+				const auto run_pos =
+				    NumericCast<idx_t>(std::lower_bound(search_begin, search_end, needle) - level_data);
+				const auto run_begin = NumericCast<idx_t>(search_begin - level_data);
 				aggregate(level, run_begin, run_pos);
 				curr.second += level_width;
 			}

package/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_streaming_window.hpp

@@ -18,6 +18,8 @@ class PhysicalStreamingWindow : public PhysicalOperator {
 public:
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::STREAMING_WINDOW;
 
+	static bool IsStreamingFunction(unique_ptr<Expression> &expr);
+
 public:
 	PhysicalStreamingWindow(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list,
 	                        idx_t estimated_cardinality,

package/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_window.hpp

@@ -50,6 +50,8 @@ public:
 	bool SupportsBatchIndex() const override;
 	OrderPreservationType SourceOrder() const override;
 
+	double GetProgress(ClientContext &context, GlobalSourceState &gstate_p) const override;
+
 public:
 	// Sink interface
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;