duckdb 0.9.3-dev2.0 → 0.10.0

package/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_copy_database.hpp

@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/persistent/physical_copy_database.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/execution/physical_operator.hpp"
+#include "duckdb/planner/operator/logical_copy_database.hpp"
+
+namespace duckdb {
+
+class PhysicalCopyDatabase : public PhysicalOperator {
+public:
+	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::COPY_DATABASE;
+
+public:
+	PhysicalCopyDatabase(vector<LogicalType> types, idx_t estimated_cardinality, unique_ptr<CopyDatabaseInfo> info_p);
+	~PhysicalCopyDatabase() override;
+
+	unique_ptr<CopyDatabaseInfo> info;
+
+public:
+	// Source interface
+	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
+
+	bool IsSource() const override {
+		return true;
+	}
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_copy_to_file.hpp

@@ -8,11 +8,11 @@
 
 #pragma once
 
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parser/parsed_data/copy_info.hpp"
-#include "duckdb/function/copy_function.hpp"
 #include "duckdb/common/file_system.hpp"
 #include "duckdb/common/filename_pattern.hpp"
+#include "duckdb/execution/physical_operator.hpp"
+#include "duckdb/function/copy_function.hpp"
+#include "duckdb/parser/parsed_data/copy_info.hpp"
 
 namespace duckdb {
 
@@ -30,9 +30,11 @@ public:
 	string file_path;
 	bool use_tmp_file;
 	FilenamePattern filename_pattern;
+	string file_extension;
 	bool overwrite_or_ignore;
 	bool parallel;
 	bool per_thread_output;
+	optional_idx file_size_bytes;
 
 	bool partition_output;
 	vector<idx_t> partition_columns;
@@ -69,5 +71,8 @@ public:
 	}
 
 	static void MoveTmpFile(ClientContext &context, const string &tmp_file_path);
+
+private:
+	unique_ptr<GlobalFunctionData> CreateFileState(ClientContext &context, GlobalSinkState &sink) const;
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_export.hpp

@@ -16,6 +16,17 @@
 #include "duckdb/parser/parsed_data/exported_table_data.hpp"
 
 namespace duckdb {
+
+struct ExportEntries {
+	vector<reference<CatalogEntry>> schemas;
+	vector<reference<CatalogEntry>> custom_types;
+	vector<reference<CatalogEntry>> sequences;
+	vector<reference<CatalogEntry>> tables;
+	vector<reference<CatalogEntry>> views;
+	vector<reference<CatalogEntry>> indexes;
+	vector<reference<CatalogEntry>> macros;
+};
+
 //! Parse a file from disk using a specified copy function and return the set of chunks retrieved from the file
 class PhysicalExport : public PhysicalOperator {
 public:
@@ -44,6 +55,9 @@ public:
 		return true;
 	}
 
+	static void ExtractEntries(ClientContext &context, vector<reference<SchemaCatalogEntry>> &schemas,
+	                           ExportEntries &result);
+
 public:
 	// Sink interface
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;

package/src/duckdb/src/include/duckdb/execution/operator/scan/physical_column_data_scan.hpp

@@ -23,10 +23,7 @@ public:
 	                       unique_ptr<ColumnDataCollection> owned_collection = nullptr);
 
 	PhysicalColumnDataScan(vector<LogicalType> types, PhysicalOperatorType op_type, idx_t estimated_cardinality,
-	                       idx_t cte_index)
-	    : PhysicalOperator(op_type, std::move(types), estimated_cardinality), collection(nullptr),
-	      cte_index(cte_index) {
-	}
+	                       idx_t cte_index);
 
 	// the column data collection to scan
 	optional_ptr<ColumnDataCollection> collection;

package/src/duckdb/src/include/duckdb/execution/operator/scan/physical_expression_scan.hpp

@@ -8,7 +8,6 @@
 
 #pragma once
 
-#include "duckdb/common/types/chunk_collection.hpp"
 #include "duckdb/execution/physical_operator.hpp"
 #include "duckdb/planner/expression.hpp"
 

package/src/duckdb/src/include/duckdb/execution/operator/set/physical_cte.hpp

@@ -24,39 +24,44 @@ public:
 	            unique_ptr<PhysicalOperator> bottom, idx_t estimated_cardinality);
 	~PhysicalCTE() override;
 
+	vector<const_reference<PhysicalOperator>> cte_scans;
+
 	std::shared_ptr<ColumnDataCollection> working_table;
-	shared_ptr<MetaPipeline> recursive_meta_pipeline;
 
 	idx_t table_index;
 	string ctename;
 
-public:
-	// Source interface
-	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
-
-	bool IsSource() const override {
-		return true;
-	}
-
 public:
 	// Sink interface
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
 
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
+	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
+
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 
 	bool IsSink() const override {
 		return true;
 	}
 
+	bool ParallelSink() const override {
+		return true;
+	}
+
+	bool SinkOrderDependent() const override {
+		return false;
+	}
+
+	bool RequiresBatchIndex() const override {
+		return false;
+	}
+
 	string ParamsToString() const override;
 
 public:
 	void BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) override;
 
 	vector<const_reference<PhysicalOperator>> GetSources() const override;
-
-private:
-	void ExecuteRecursivePipelines(ExecutionContext &context) const;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/set/physical_recursive_cte.hpp

@@ -50,6 +50,10 @@ public:
 		return true;
 	}
 
+	bool ParallelSink() const override {
+		return true;
+	}
+
 	string ParamsToString() const override;
 
 public:

package/src/duckdb/src/include/duckdb/execution/operator/set/physical_union.hpp

@@ -18,7 +18,9 @@ public:
 
 public:
 	PhysicalUnion(vector<LogicalType> types, unique_ptr<PhysicalOperator> top, unique_ptr<PhysicalOperator> bottom,
-	              idx_t estimated_cardinality);
+	              idx_t estimated_cardinality, bool allow_out_of_order);
+
+	bool allow_out_of_order;
 
 public:
 	void BuildPipelines(Pipeline &current, MetaPipeline &meta_pipeline) override;

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

@@ -133,7 +133,8 @@ public:
 	// Sink interface
 
 	//! The sink method is called constantly with new input, as long as new input is available. Note that this method
-	//! CAN be called in parallel, proper locking is needed when accessing data inside the GlobalSinkState.
+	//! CAN be called in parallel, proper locking is needed when accessing dat
+	//! a inside the GlobalSinkState.
 	virtual SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const;
 	// The combine is called when a single thread has completed execution of its part of the pipeline, it is the final
 	// time that a specific LocalSinkState is accessible. This method can be called in parallel while other Sink() or

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

@@ -13,6 +13,7 @@
 #include "duckdb/planner/logical_operator.hpp"
 #include "duckdb/planner/logical_tokens.hpp"
 #include "duckdb/planner/operator/logical_limit_percent.hpp"
+#include "duckdb/planner/joinside.hpp"
 #include "duckdb/catalog/dependency_list.hpp"
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/common/unordered_set.hpp"
@@ -33,7 +34,7 @@ public:
 	//! This data structure is used to establish it.
 	unordered_map<idx_t, std::shared_ptr<ColumnDataCollection>> recursive_cte_tables;
 	//! Materialized CTE ids must be collected.
-	unordered_set<idx_t> materialized_ctes;
+	unordered_map<idx_t, vector<const_reference<PhysicalOperator>>> materialized_ctes;
 
 public:
 	//! Creates a plan from the logical operator. This involves resolving column bindings and generating physical
@@ -45,6 +46,8 @@ public:
 	//! Whether or not we should preserve insertion order for executing the given sink
 	static bool PreserveInsertionOrder(ClientContext &context, PhysicalOperator &plan);
 
+	static bool HasEquality(vector<JoinCondition> &conds, idx_t &range_count);
+
 protected:
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalOperator &op);
 
@@ -52,9 +55,11 @@ protected:
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalAnyJoin &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalColumnDataGet &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalComparisonJoin &op);
+	unique_ptr<PhysicalOperator> CreatePlan(LogicalCopyDatabase &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalCreate &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalCreateTable &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalCreateIndex &op);
+	unique_ptr<PhysicalOperator> CreatePlan(LogicalCreateSecret &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalCrossProduct &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalDelete &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalDelimGet &op);
@@ -83,7 +88,6 @@ protected:
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalSample &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalSet &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalReset &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalShow &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalSimple &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalUnnest &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalRecursiveCTE &op);

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

@@ -50,8 +50,10 @@ public:
 	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, GlobalSinkState &sink,
 	                         OperatorSourceInput &input) const;
 
+	double GetProgress(ClientContext &context, GlobalSinkState &sink_p, GlobalSourceState &gstate) const;
+
 	const TupleDataLayout &GetLayout() const;
-	idx_t NumberOfPartitions(GlobalSinkState &sink) const;
+	idx_t MaxThreads(GlobalSinkState &sink) const;
 	static void SetMultiScan(GlobalSinkState &sink);
 
 private:

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

@@ -8,9 +8,11 @@
 
 #pragma once
 
+#include "duckdb/common/allocator.hpp"
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/random_engine.hpp"
-#include "duckdb/common/types/chunk_collection.hpp"
+#include "duckdb/common/types/data_chunk.hpp"
+
 #include "duckdb/common/queue.hpp"
 
 namespace duckdb {
@@ -24,20 +26,23 @@ public:
 
 	void SetNextEntry();
 
-	void ReplaceElement();
-
+	void ReplaceElement(double with_weight = -1);
 	//! The random generator
 	RandomEngine random;
 	//! Priority queue of [random element, index] for each of the elements in the sample
 	std::priority_queue<std::pair<double, idx_t>> reservoir_weights;
 	//! The next element to sample
-	idx_t next_index;
+	idx_t next_index_to_sample;
 	//! The reservoir threshold of the current min entry
-	double min_threshold;
+	double min_weight_threshold;
 	//! The reservoir index of the current min entry
-	idx_t min_entry;
+	idx_t min_weighted_entry_index;
 	//! The current count towards next index (i.e. we will replace an entry in next_index - current_count tuples)
-	idx_t current_count;
+	//! The number of entries "seen" before choosing one that will go in our reservoir sample.
+	idx_t num_entries_to_skip_b4_next_sample;
+	//! when collecting a sample in parallel, we want to know how many values each thread has seen
+	//! so we can collect the samples from the thread local states in a uniform manner
+	idx_t num_entries_seen_total;
 };
 
 class BlockingSample {
@@ -50,13 +55,17 @@ public:
 	//! Add a chunk of data to the sample
 	virtual void AddToReservoir(DataChunk &input) = 0;
 
+	virtual void Finalize() = 0;
 	//! Fetches a chunk from the sample. Note that this method is destructive and should only be used after the
-	// sample is completely built.
+	//! sample is completely built.
 	virtual unique_ptr<DataChunk> GetChunk() = 0;
+	BaseReservoirSampling base_reservoir_sample;
+
+	virtual void Serialize(Serializer &serializer) const;
+	static unique_ptr<BlockingSample> Deserialize(Deserializer &deserializer);
 
 protected:
 	//! The reservoir sampling
-	BaseReservoirSampling base_reservoir_sample;
 	RandomEngine &random;
 };
 
@@ -71,19 +80,24 @@ public:
 	//! Fetches a chunk from the sample. Note that this method is destructive and should only be used after the
 	//! sample is completely built.
 	unique_ptr<DataChunk> GetChunk() override;
+	void Finalize() override;
 
 private:
 	//! Replace a single element of the input
-	void ReplaceElement(DataChunk &input, idx_t index_in_chunk);
-
+	void ReplaceElement(DataChunk &input, idx_t index_in_chunk, double with_weight = -1);
+	void InitializeReservoir(DataChunk &input);
 	//! Fills the reservoir up until sample_count entries, returns how many entries are still required
 	idx_t FillReservoir(DataChunk &input);
 
-private:
-	//! The size of the reservoir sample
+public:
+	Allocator &allocator;
+	//! The size of the reservoir sample.
+	//! when calculating percentages, it is set to reservoir_threshold * percentage
+	//! when explicit number used, sample_count = number
 	idx_t sample_count;
+	bool reservoir_initialized;
 	//! The current reservoir
-	ChunkCollection reservoir;
+	unique_ptr<DataChunk> reservoir_chunk;
 };
 
 //! The reservoir sample sample_size class maintains a streaming sample of variable size
@@ -99,9 +113,7 @@ public:
 	//! Fetches a chunk from the sample. Note that this method is destructive and should only be used after the
 	//! sample is completely built.
 	unique_ptr<DataChunk> GetChunk() override;
-
-private:
-	void Finalize();
+	void Finalize() override;
 
 private:
 	Allocator &allocator;
@@ -109,11 +121,13 @@ private:
 	double sample_percentage;
 	//! The fixed sample size of the sub-reservoirs
 	idx_t reservoir_sample_size;
+
 	//! The current sample
 	unique_ptr<ReservoirSample> current_sample;
+
 	//! The set of finished samples of the reservoir sample
 	vector<unique_ptr<ReservoirSample>> finished_samples;
-	//! The amount of tuples that have been processed so far
+	//! The amount of tuples that have been processed so far (not put in the reservoir, just processed)
 	idx_t current_count = 0;
 	//! Whether or not the stream is finalized. The stream is automatically finalized on the first call to GetChunk();
 	bool is_finalized;

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

@@ -0,0 +1,57 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/task_error_manager.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/error_data.hpp"
+#include "duckdb/common/mutex.hpp"
+#include "duckdb/common/vector.hpp"
+
+namespace duckdb {
+
+class TaskErrorManager {
+public:
+	void PushError(ErrorData error) {
+		lock_guard<mutex> elock(error_lock);
+		this->exceptions.push_back(std::move(error));
+	}
+
+	ErrorData GetError() {
+		lock_guard<mutex> elock(error_lock);
+		D_ASSERT(!exceptions.empty());
+
+		// FIXME: Should we try to get the biggest priority error?
+		// In case the first exception is a StandardException but a regular Exception or a FatalException occurred
+		// Maybe we should throw the more critical exception instead, as that changes behavior.
+		auto &entry = exceptions[0];
+		return entry;
+	}
+
+	bool HasError() {
+		lock_guard<mutex> elock(error_lock);
+		return !exceptions.empty();
+	}
+
+	void ThrowException() {
+		lock_guard<mutex> elock(error_lock);
+		D_ASSERT(!exceptions.empty());
+		auto &entry = exceptions[0];
+		entry.Throw();
+	}
+
+	void Reset() {
+		lock_guard<mutex> elock(error_lock);
+		exceptions.clear();
+	}
+
+private:
+	mutex error_lock;
+	//! Exceptions that occurred during the execution of the current query
+	vector<ErrorData> exceptions;
+};
+} // namespace duckdb

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

@@ -176,6 +176,7 @@ class WindowAggregateExecutor : public WindowExecutor {
 public:
 	bool IsConstantAggregate();
 	bool IsCustomAggregate();
+	bool IsDistinctAggregate();
 
 	WindowAggregateExecutor(BoundWindowExpression &wexpr, ClientContext &context, const idx_t payload_count,
 	                        const ValidityMask &partition_mask, const ValidityMask &order_mask,
@@ -257,6 +258,7 @@ public:
 	                    const ValidityMask &partition_mask, const ValidityMask &order_mask);
 
 	void Sink(DataChunk &input_chunk, const idx_t input_idx, const idx_t total_count) override;
+	unique_ptr<WindowExecutorState> GetExecutorState() const override;
 
 protected:
 	// IGNORE NULLS

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

@@ -8,11 +8,13 @@
 
 #pragma once
 
+#include "duckdb/common/sort/sort.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/execution/physical_operator.hpp"
 #include "duckdb/function/aggregate_function.hpp"
 #include "duckdb/common/enums/window_aggregation_mode.hpp"
 #include "duckdb/execution/operator/aggregate/aggregate_object.hpp"
+#include "duckdb/parser/expression/window_expression.hpp"
 
 namespace duckdb {
 
@@ -39,27 +41,37 @@ public:
 
 class WindowAggregator {
 public:
-	WindowAggregator(AggregateObject aggr, const LogicalType &result_type_p, idx_t partition_count);
+	WindowAggregator(AggregateObject aggr, const LogicalType &result_type_p, const WindowExcludeMode exclude_mode_p,
+	                 idx_t partition_count);
 	virtual ~WindowAggregator();
 
+	//	Access
+	const DataChunk &GetInputs() const {
+		return inputs;
+	}
+	const ValidityMask &GetFilterMask() const {
+		return filter_mask;
+	}
+
 	//	Build
 	virtual void Sink(DataChunk &payload_chunk, SelectionVector *filter_sel, idx_t filtered);
-	virtual void Finalize();
+	virtual void Finalize(const FrameStats &stats);
 
 	//	Probe
 	virtual unique_ptr<WindowAggregatorState> GetLocalState() const = 0;
-	virtual void Evaluate(WindowAggregatorState &lstate, const idx_t *begins, const idx_t *ends, Vector &result,
-	                      idx_t count) const = 0;
+	virtual void Evaluate(WindowAggregatorState &lstate, const DataChunk &bounds, Vector &result, idx_t count,
+	                      idx_t row_idx) const = 0;
 
-protected:
-	AggregateObject aggr;
+	//! A description of the aggregator
+	const AggregateObject aggr;
 	//! The result type of the window function
-	LogicalType result_type;
-
+	const LogicalType result_type;
 	//! The cardinality of the partition
 	const idx_t partition_count;
 	//! The size of a single aggregate state
 	const idx_t state_size;
+
+protected:
 	//! Partition data chunk
 	DataChunk inputs;
 
@@ -69,21 +81,37 @@ protected:
 	idx_t filter_pos;
 	//! The state used by the aggregator to build.
 	unique_ptr<WindowAggregatorState> gstate;
+
+public:
+	//! The window exclusion clause
+	const WindowExcludeMode exclude_mode;
+};
+
+// Used for validation
+class WindowNaiveAggregator : public WindowAggregator {
+public:
+	WindowNaiveAggregator(AggregateObject aggr, const LogicalType &result_type_p,
+	                      const WindowExcludeMode exclude_mode_p, idx_t partition_count);
+	~WindowNaiveAggregator() override;
+
+	unique_ptr<WindowAggregatorState> GetLocalState() const override;
+	void Evaluate(WindowAggregatorState &lstate, const DataChunk &bounds, Vector &result, idx_t count,
+	              idx_t row_idx) const override;
 };
 
 class WindowConstantAggregator : public WindowAggregator {
 public:
 	WindowConstantAggregator(AggregateObject aggr, const LogicalType &result_type_p, const ValidityMask &partition_mask,
-	                         const idx_t count);
+	                         WindowExcludeMode exclude_mode_p, const idx_t count);
 	~WindowConstantAggregator() override {
 	}
 
 	void Sink(DataChunk &payload_chunk, SelectionVector *filter_sel, idx_t filtered) override;
-	void Finalize() override;
+	void Finalize(const FrameStats &stats) override;
 
 	unique_ptr<WindowAggregatorState> GetLocalState() const override;
-	void Evaluate(WindowAggregatorState &lstate, const idx_t *begins, const idx_t *ends, Vector &result,
-	              idx_t count) const override;
+	void Evaluate(WindowAggregatorState &lstate, const DataChunk &bounds, Vector &result, idx_t count,
+	              idx_t row_idx) const override;
 
 private:
 	void AggregateInit();
@@ -107,24 +135,35 @@ private:
 
 class WindowCustomAggregator : public WindowAggregator {
 public:
-	WindowCustomAggregator(AggregateObject aggr, const LogicalType &result_type_p, idx_t partition_count);
+	WindowCustomAggregator(AggregateObject aggr, const LogicalType &result_type_p,
+	                       const WindowExcludeMode exclude_mode_p, idx_t partition_count);
 	~WindowCustomAggregator() override;
 
+	void Finalize(const FrameStats &stats) override;
+
 	unique_ptr<WindowAggregatorState> GetLocalState() const override;
-	void Evaluate(WindowAggregatorState &lstate, const idx_t *begins, const idx_t *ends, Vector &result,
-	              idx_t count) const override;
+	void Evaluate(WindowAggregatorState &lstate, const DataChunk &bounds, Vector &result, idx_t count,
+	              idx_t row_idx) const override;
+
+	//! Partition description
+	unique_ptr<WindowPartitionInput> partition_input;
+
+	//! Data pointer that contains a single state, used for global custom window state
+	unique_ptr<WindowAggregatorState> gstate;
 };
 
 class WindowSegmentTree : public WindowAggregator {
+
 public:
-	WindowSegmentTree(AggregateObject aggr, const LogicalType &result_type, idx_t count, WindowAggregationMode mode_p);
+	WindowSegmentTree(AggregateObject aggr, const LogicalType &result_type, WindowAggregationMode mode_p,
+	                  const WindowExcludeMode exclude_mode_p, idx_t count);
 	~WindowSegmentTree() override;
 
-	void Finalize() override;
+	void Finalize(const FrameStats &stats) override;
 
 	unique_ptr<WindowAggregatorState> GetLocalState() const override;
-	void Evaluate(WindowAggregatorState &lstate, const idx_t *begins, const idx_t *ends, Vector &result,
-	              idx_t count) const override;
+	void Evaluate(WindowAggregatorState &lstate, const DataChunk &bounds, Vector &result, idx_t count,
+	              idx_t row_idx) const override;
 
 public:
 	void ConstructTree();
@@ -149,4 +188,47 @@ public:
 	static constexpr idx_t TREE_FANOUT = 16;
 };
 
+class WindowDistinctAggregator : public WindowAggregator {
+public:
+	using GlobalSortStatePtr = unique_ptr<GlobalSortState>;
+	class DistinctSortTree;
+
+	WindowDistinctAggregator(AggregateObject aggr, const LogicalType &result_type,
+	                         const WindowExcludeMode exclude_mode_p, idx_t count, ClientContext &context);
+	~WindowDistinctAggregator() override;
+
+	//	Build
+	void Sink(DataChunk &args_chunk, SelectionVector *filter_sel, idx_t filtered) override;
+	void Finalize(const FrameStats &stats) override;
+
+	//	Evaluate
+	unique_ptr<WindowAggregatorState> GetLocalState() const override;
+	void Evaluate(WindowAggregatorState &lstate, const DataChunk &bounds, Vector &result, idx_t count,
+	              idx_t row_idx) const override;
+
+	ClientContext &context;
+	ArenaAllocator allocator;
+
+	//	Single threaded sorting for now
+	GlobalSortStatePtr global_sort;
+	LocalSortState local_sort;
+	idx_t payload_pos;
+	idx_t memory_per_thread;
+
+	vector<LogicalType> payload_types;
+	DataChunk sort_chunk;
+	DataChunk payload_chunk;
+
+	//! The merge sort tree for the aggregate.
+	unique_ptr<DistinctSortTree> merge_sort_tree;
+
+	//! The actual window segment tree: an array of aggregate states that represent all the intermediate nodes
+	unsafe_unique_array<data_t> levels_flat_native;
+	//! For each level, the starting location in the levels_flat_native array
+	vector<idx_t> levels_flat_start;
+
+	//! The total number of internal nodes of the tree, stored in levels_flat_native
+	idx_t internal_nodes;
+};
+
 } // namespace duckdb