duckdb 0.8.2-dev37.0 → 0.8.2-dev3989.0

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

@@ -7,78 +7,89 @@
 //===----------------------------------------------------------------------===//
 #pragma once
 
+#include "duckdb/execution/index/art/art.hpp"
+#include "duckdb/execution/index/art/fixed_size_allocator.hpp"
 #include "duckdb/execution/index/art/node.hpp"
 
 namespace duckdb {
 
 // classes
 class ARTKey;
-class PrefixSegment;
 
+//! The Prefix is a special node type that contains up to PREFIX_SIZE bytes, and one byte for the count,
+//! and a Node pointer. This pointer either points to another prefix
+//! node or the 'actual' ART node.
 class Prefix {
 public:
-	//! Number of bytes in this prefix
-	uint32_t count;
-	union {
-		//! Pointer to the head of the list of prefix segments
-		Node ptr;
-		//! Inlined prefix bytes
-		uint8_t inlined[Node::PREFIX_INLINE_BYTES];
-	} data;
+	//! Up to PREFIX_SIZE bytes of prefix data and the count
+	uint8_t data[Node::PREFIX_SIZE + 1];
+	//! A pointer to the next ART node
+	Node ptr;
 
 public:
-	//! Delete all prefix segments (if not inlined) and reset all fields
-	void Free(ART &art);
-	//! Initializes all the fields of an empty prefix
-	inline void Initialize() {
-		count = 0;
+	//! Get a new empty prefix node, might cause a new buffer allocation
+	static Prefix &New(ART &art, Node &node);
+	//! Create a new prefix node containing a single byte and a pointer to a next node
+	static Prefix &New(ART &art, Node &node, uint8_t byte, Node next);
+	//! Get a new chain of prefix nodes, might cause new buffer allocations,
+	//! with the node parameter holding the tail of the chain
+	static void New(ART &art, reference<Node> &node, const ARTKey &key, const uint32_t depth, uint32_t count);
+	//! Free the node (and its subtree)
+	static void Free(ART &art, Node &node);
+	//! Get a reference to the prefix
+	static inline Prefix &Get(const ART &art, const Node ptr) {
+		D_ASSERT(!ptr.IsSerialized());
+		return *Node::GetAllocator(art, NType::PREFIX).Get<Prefix>(ptr);
 	}
-	//! Initialize a prefix from an ART key
-	void Initialize(ART &art, const ARTKey &key, const uint32_t depth, const uint32_t count_p);
-	//! Initialize a prefix from another prefix up to count
-	void Initialize(ART &art, const Prefix &other, const uint32_t count_p);
 
-	//! Initializes a merge by incrementing the buffer IDs of the prefix segments
-	void InitializeMerge(ART &art, const idx_t buffer_count);
+	//! Initializes a merge by incrementing the buffer ID of the prefix and its child node(s)
+	static void InitializeMerge(ART &art, Node &node, const ARTFlags &flags);
 
-	//! Move a prefix into this prefix
-	inline void Move(Prefix &other) {
-		count = other.count;
-		data = other.data;
-		other.Initialize();
+	//! Appends a byte and a child_prefix to prefix. If there is no prefix, than it pushes the
+	//! byte on top of child_prefix. If there is no child_prefix, then it creates a new
+	//! prefix node containing that byte
+	static void Concatenate(ART &art, Node &prefix_node, const uint8_t byte, Node &child_prefix_node);
+	//! Traverse a prefix and a key until (1) encountering a non-prefix node, or (2) encountering
+	//! a mismatching byte, in which case depth indexes the mismatching byte in the key
+	static idx_t Traverse(ART &art, reference<Node> &prefix_node, const ARTKey &key, idx_t &depth);
+	//! Traverse two prefixes to find (1) that they match (so far), or (2) that they have a mismatching position,
+	//! or (3) that one prefix contains the other prefix
+	static bool Traverse(ART &art, reference<Node> &l_node, reference<Node> &r_node, idx_t &mismatch_position);
+	//! Returns the byte at position
+	static inline uint8_t GetByte(const ART &art, const Node &prefix_node, const idx_t position) {
+		auto prefix = Prefix::Get(art, prefix_node);
+		D_ASSERT(position < Node::PREFIX_SIZE);
+		D_ASSERT(position < prefix.data[Node::PREFIX_SIZE]);
+		return prefix.data[position];
 	}
-	//! Append a prefix to this prefix
-	void Append(ART &art, const Prefix &other);
-	//! Concatenate prefix with a partial key byte and another prefix: other.prefix + byte + this->prefix
-	void Concatenate(ART &art, const uint8_t byte, const Prefix &other);
-	//! Removes the first n bytes, and returns the new first byte
-	uint8_t Reduce(ART &art, const idx_t reduce_count);
+	//! Removes the first n bytes from the prefix and shifts all subsequent bytes in the
+	//! prefix node(s) by n. Frees empty prefix nodes
+	static void Reduce(ART &art, Node &prefix_node, const idx_t n);
+	//! Splits the prefix at position. prefix_node then references the ptr (if any bytes left before
+	//! the split), or stays unchanged (no bytes left before the split). child_node references
+	//! the node after the split, which is either a new prefix node, or ptr
+	static void Split(ART &art, reference<Node> &prefix_node, Node &child_node, idx_t position);
 
-	//! Get the byte at position
-	uint8_t GetByte(const ART &art, const idx_t position) const;
-	//! Compare the key with the prefix of the node, return the position where they mismatch
-	uint32_t KeyMismatchPosition(const ART &art, const ARTKey &key, const uint32_t depth) const;
-	//! Compare this prefix to another prefix, return the position where they mismatch, or count otherwise
-	uint32_t MismatchPosition(const ART &art, const Prefix &other) const;
+	//! Returns the string representation of the node, or only traverses and verifies the node and its subtree
+	static string VerifyAndToString(ART &art, Node &node, const bool only_verify);
 
-	//! Serialize this prefix
-	void Serialize(const ART &art, MetaBlockWriter &writer) const;
-	//! Deserialize this prefix
-	void Deserialize(ART &art, MetaBlockReader &reader);
+	//! Serialize this node and all subsequent nodes
+	static BlockPointer Serialize(ART &art, Node &node, MetadataWriter &writer);
+	//! Deserialize this node and all subsequent prefix nodes
+	static void Deserialize(ART &art, Node &node, MetadataReader &reader);
 
-	//! Vacuum the prefix segments of a prefix, if not inlined
-	void Vacuum(ART &art);
+	//! Vacuum the child of the node
+	static void Vacuum(ART &art, Node &node, const ARTFlags &flags);
 
 private:
-	//! Returns whether this prefix is inlined
-	inline bool IsInlined() const {
-		return count <= Node::PREFIX_INLINE_BYTES;
-	}
-	//! Moves all inlined bytes onto a prefix segment, does not change the size
-	//! so this will be an (temporarily) invalid prefix
-	PrefixSegment &MoveInlinedToSegment(ART &art);
-	//! Inlines up to eight bytes on the first prefix segment
-	void MoveSegmentToInlined(ART &art);
+	//! Appends the byte to this prefix node, or creates a subsequent prefix node,
+	//! if this node is full
+	Prefix &Append(ART &art, const uint8_t byte);
+	//! Appends the other_prefix and all its subsequent prefix nodes to this prefix node.
+	//! Also frees all copied/appended nodes
+	void Append(ART &art, Node other_prefix);
+	//! Get the total count of bytes in the chain of prefixes, with the node reference pointing to first non-prefix node
+	static idx_t TotalCount(ART &art, reference<Node> &node);
 };
 
 } // namespace duckdb

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

@@ -8,17 +8,18 @@
 
 #pragma once
 
+#include "duckdb/execution/operator/aggregate/distinct_aggregate_data.hpp"
+#include "duckdb/execution/operator/aggregate/grouped_aggregate_data.hpp"
 #include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/storage/data_table.hpp"
-#include "duckdb/parser/group_by_node.hpp"
 #include "duckdb/execution/radix_partitioned_hashtable.hpp"
-#include "duckdb/execution/operator/aggregate/grouped_aggregate_data.hpp"
-#include "duckdb/execution/operator/aggregate/distinct_aggregate_data.hpp"
+#include "duckdb/parser/group_by_node.hpp"
+#include "duckdb/storage/data_table.hpp"
 
 namespace duckdb {
 
 class ClientContext;
 class BufferManager;
+class PhysicalHashAggregate;
 
 struct HashAggregateGroupingData {
 public:
@@ -106,9 +107,9 @@ public:
 public:
 	// Sink interface
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const override;
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
+	                          OperatorSinkFinalizeInput &input) const override;
 	SinkFinalizeType FinalizeInternal(Pipeline &pipeline, Event &event, ClientContext &context, GlobalSinkState &gstate,
 	                                  bool check_distinct) const;
 
@@ -141,7 +142,7 @@ private:
 	SinkFinalizeType FinalizeDistinct(Pipeline &pipeline, Event &event, ClientContext &context,
 	                                  GlobalSinkState &gstate) const;
 	//! Combine the distinct aggregates
-	void CombineDistinct(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const;
+	void CombineDistinct(ExecutionContext &context, OperatorSinkCombineInput &input) const;
 	//! Sink the distinct aggregates for a single grouping
 	void SinkDistinctGrouping(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input,
 	                          idx_t grouping_idx) const;

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

@@ -46,7 +46,7 @@ public:
 public:
 	// Sink interface
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const override;
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;

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

@@ -44,9 +44,9 @@ public:
 public:
 	// Sink interface
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const override;
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
+	                          OperatorSinkFinalizeInput &input) const override;
 
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
@@ -68,7 +68,7 @@ private:
 	SinkFinalizeType FinalizeDistinct(Pipeline &pipeline, Event &event, ClientContext &context,
 	                                  GlobalSinkState &gstate) const;
 	//! Combine the distinct aggregates
-	void CombineDistinct(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const;
+	void CombineDistinct(ExecutionContext &context, OperatorSinkCombineInput &input) const;
 	//! Sink the distinct aggregates
 	void SinkDistinct(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const;
 };

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

@@ -36,6 +36,8 @@ public:
 	                                                 GlobalSourceState &gstate) const override;
 	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
 	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
+	idx_t GetBatchIndex(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
+	                    LocalSourceState &lstate) const override;
 
 	bool IsSource() const override {
 		return true;
@@ -44,16 +46,15 @@ public:
 		return true;
 	}
 
-	OrderPreservationType SourceOrder() const override {
-		return OrderPreservationType::NO_ORDER;
-	}
+	bool SupportsBatchIndex() const override;
+	OrderPreservationType SourceOrder() const override;
 
 public:
 	// Sink interface
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const override;
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
+	                          OperatorSinkFinalizeInput &input) const override;
 
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;

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

@@ -22,9 +22,9 @@ public:
 public:
 	// Sink interface
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const override;
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
+	                          OperatorSinkFinalizeInput &input) const override;
 
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;

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

@@ -34,7 +34,7 @@ public:
 	// Sink Interface
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
+	                          OperatorSinkFinalizeInput &input) const override;
 
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
 

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

@@ -44,7 +44,7 @@ public:
 public:
 	// Sink Interface
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
 

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

@@ -24,7 +24,7 @@ public:
 public:
 	// Sink interface
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;

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

@@ -38,9 +38,9 @@ public:
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
 
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const override;
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
+	                          OperatorSinkFinalizeInput &input) const override;
 
 	bool IsSink() const override {
 		return info->has_table;

package/src/duckdb/src/include/duckdb/execution/operator/join/physical_asof_join.hpp

@@ -13,8 +13,7 @@
 
 namespace duckdb {
 
-//! PhysicalAsOfJoin represents a piecewise merge loop join between
-//! two tables
+//! PhysicalAsOfJoin represents an as-of join between two tables
 class PhysicalAsOfJoin : public PhysicalComparisonJoin {
 public:
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::ASOF_JOIN;
@@ -24,6 +23,7 @@ public:
 
 	vector<LogicalType> join_key_types;
 	vector<column_t> null_sensitive;
+	ExpressionType comparison_type;
 
 	// Equalities
 	vector<unique_ptr<Expression>> lhs_partitions;
@@ -58,7 +58,7 @@ public:
 	SourceResultType GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const override;
 
 	bool IsSource() const override {
-		return IsRightOuterJoin(join_type);
+		return true;
 	}
 	bool ParallelSource() const override {
 		return true;
@@ -69,9 +69,9 @@ public:
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
+	                          OperatorSinkFinalizeInput &input) const override;
 
 	bool IsSink() const override {
 		return true;
@@ -79,13 +79,6 @@ public:
 	bool ParallelSink() const override {
 		return true;
 	}
-
-private:
-	// resolve joins that output max N elements (SEMI, ANTI, MARK)
-	void ResolveSimpleJoin(ExecutionContext &context, DataChunk &input, DataChunk &chunk, OperatorState &state) const;
-	// resolve joins that can potentially output N*M elements (INNER, LEFT, FULL)
-	OperatorResultType ResolveComplexJoin(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-	                                      OperatorState &state) const;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/join/physical_blockwise_nl_join.hpp

@@ -59,7 +59,7 @@ public:
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
+	                          OperatorSinkFinalizeInput &input) const override;
 
 	bool IsSink() const override {
 		return true;

package/src/duckdb/src/include/duckdb/execution/operator/join/physical_delim_join.hpp

@@ -35,9 +35,9 @@ public:
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const override;
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
+	                          OperatorSinkFinalizeInput &input) const override;
 
 	bool IsSink() const override {
 		return true;

package/src/duckdb/src/include/duckdb/execution/operator/join/physical_hash_join.hpp

@@ -79,9 +79,9 @@ public:
 
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
+	                          OperatorSinkFinalizeInput &input) const override;
 
 	bool IsSink() const override {
 		return true;

package/src/duckdb/src/include/duckdb/execution/operator/join/physical_iejoin.hpp

@@ -20,7 +20,7 @@ public:
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::IE_JOIN;
 
 public:
-	PhysicalIEJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left, unique_ptr<PhysicalOperator> right,
+	PhysicalIEJoin(LogicalComparisonJoin &op, unique_ptr<PhysicalOperator> left, unique_ptr<PhysicalOperator> right,
 	               vector<JoinCondition> cond, JoinType join_type, idx_t estimated_cardinality);
 
 	vector<LogicalType> join_key_types;
@@ -51,9 +51,9 @@ public:
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
+	                          OperatorSinkFinalizeInput &input) const override;
 
 	bool IsSink() const override {
 		return true;

package/src/duckdb/src/include/duckdb/execution/operator/join/physical_nested_loop_join.hpp

@@ -54,9 +54,9 @@ public:
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
+	                          OperatorSinkFinalizeInput &input) const override;
 
 	bool IsSink() const override {
 		return true;

package/src/duckdb/src/include/duckdb/execution/operator/join/physical_piecewise_merge_join.hpp

@@ -22,7 +22,7 @@ public:
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::PIECEWISE_MERGE_JOIN;
 
 public:
-	PhysicalPiecewiseMergeJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left,
+	PhysicalPiecewiseMergeJoin(LogicalComparisonJoin &op, unique_ptr<PhysicalOperator> left,
 	                           unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond, JoinType join_type,
 	                           idx_t estimated_cardinality);
 
@@ -60,9 +60,9 @@ public:
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
+	                          OperatorSinkFinalizeInput &input) const override;
 
 	bool IsSink() const override {
 		return true;

package/src/duckdb/src/include/duckdb/execution/operator/join/physical_range_join.hpp

@@ -89,10 +89,18 @@ public:
 	};
 
 public:
-	PhysicalRangeJoin(LogicalOperator &op, PhysicalOperatorType type, unique_ptr<PhysicalOperator> left,
+	PhysicalRangeJoin(LogicalComparisonJoin &op, PhysicalOperatorType type, unique_ptr<PhysicalOperator> left,
 	                  unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond, JoinType join_type,
 	                  idx_t estimated_cardinality);
 
+	// Projection mappings
+	using ProjectionMapping = vector<column_t>;
+	ProjectionMapping left_projection_map;
+	ProjectionMapping right_projection_map;
+
+	//!	The full set of types (left + right child)
+	vector<LogicalType> unprojected_types;
+
 public:
 	// Gather the result values and slice the payload columns to those values.
 	// Returns a buffer handle to the pinned heap block (if any)
@@ -102,6 +110,9 @@ public:
 	// Apply a tail condition to the current selection
 	static idx_t SelectJoinTail(const ExpressionType &condition, Vector &left, Vector &right,
 	                            const SelectionVector *sel, idx_t count, SelectionVector *true_sel);
+
+	//!	Utility to project full width internal chunks to projected results
+	void ProjectResult(DataChunk &chunk, DataChunk &result) const;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/order/physical_order.hpp

@@ -60,9 +60,9 @@ public:
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const override;
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
+	                          OperatorSinkFinalizeInput &input) const override;
 
 	bool IsSink() const override {
 		return true;

package/src/duckdb/src/include/duckdb/execution/operator/order/physical_top_n.hpp

@@ -42,9 +42,9 @@ public:
 
 public:
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const override;
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
+	                          OperatorSinkFinalizeInput &input) const override;
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
 

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

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "duckdb.hpp"
+#ifndef DUCKDB_AMALGAMATION
+#include "duckdb/storage/object_cache.hpp"
+#endif
+
+namespace duckdb {
+
+struct ReadCSVData;
+
+class CSVRejectsTable : public ObjectCacheEntry {
+public:
+	CSVRejectsTable(string name) : name(name), count(0) {
+	}
+	~CSVRejectsTable() override = default;
+	mutex write_lock;
+	string name;
+	idx_t count;
+
+	static shared_ptr<CSVRejectsTable> GetOrCreate(ClientContext &context, const string &name);
+
+	void InitializeTable(ClientContext &context, const ReadCSVData &options);
+	TableCatalogEntry &GetTable(ClientContext &context);
+
+public:
+	static string ObjectType() {
+		return "csv_rejects_table_cache";
+	}
+
+	string GetObjectType() override {
+		return ObjectType();
+	}
+};
+
+} // namespace duckdb

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

@@ -41,9 +41,9 @@ public:
 public:
 	// Sink interface
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
+	                          OperatorSinkFinalizeInput &input) const override;
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
 	void NextBatch(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate_p) const override;

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

@@ -54,9 +54,9 @@ public:
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	void NextBatch(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate_p) const override;
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
+	                          OperatorSinkFinalizeInput &input) const override;
 
 	bool RequiresBatchIndex() const override {
 		return true;

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

@@ -50,9 +50,9 @@ public:
 public:
 	// Sink interface
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
+	                          OperatorSinkFinalizeInput &input) const override;
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
 

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

@@ -40,9 +40,9 @@ public:
 public:
 	// Sink interface
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
+	                          OperatorSinkFinalizeInput &input) const override;
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
 	void NextBatch(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate_p) const override;

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

@@ -88,9 +88,9 @@ public:
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const override;
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
+	                          OperatorSinkFinalizeInput &input) const override;
 
 	bool IsSink() const override {
 		return true;