duckdb 0.8.2-dev161.0 → 0.8.2-dev1764.0

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

@@ -14,9 +14,8 @@
 
 namespace duckdb {
 
+//! Keeps track of the byte leading to the currently active child of the node
 struct IteratorEntry {
-	IteratorEntry() {
-	}
 	IteratorEntry(Node node, uint8_t byte) : node(node), byte(byte) {
 	}
 
@@ -24,16 +23,23 @@ struct IteratorEntry {
 	uint8_t byte = 0;
 };
 
-//! Keeps track of the current key in the iterator
-class IteratorCurrentKey {
+//! Keeps track of the current key in the iterator leading down to the top node in the stack
+class IteratorKey {
 public:
-	//! Push byte into current key
-	void Push(const uint8_t key);
-	//! Pops n elements from the key
-	void Pop(const idx_t n);
+	//! Pushes a byte into the current key
+	inline void Push(const uint8_t key_byte) {
+		key_bytes.push_back(key_byte);
+	}
+	//! Pops n bytes from the current key
+	inline void Pop(const idx_t n) {
+		key_bytes.resize(key_bytes.size() - n);
+	}
 
 	//! Subscript operator
-	uint8_t &operator[](idx_t idx);
+	inline uint8_t &operator[](idx_t idx) {
+		D_ASSERT(idx < key_bytes.size());
+		return key_bytes[idx];
+	}
 	//! Greater than operator
 	bool operator>(const ARTKey &k) const;
 	//! Greater than or equal to operator
@@ -42,37 +48,35 @@ public:
 	bool operator==(const ARTKey &k) const;
 
 private:
-	//! The current key position
-	idx_t cur_key_pos = 0;
-	//! The current key corresponding to the current leaf
-	vector<uint8_t> key;
+	vector<uint8_t> key_bytes;
 };
 
 class Iterator {
 public:
-	//! All information about the current key
-	IteratorCurrentKey cur_key;
+	//! Holds the current key leading down to the top node on the stack
+	IteratorKey current_key;
 	//! Pointer to the ART
-	ART *art = nullptr;
+	optional_ptr<ART> art = nullptr;
 
-	//! Scan the tree
-	bool Scan(const ARTKey &key, const idx_t &max_count, vector<row_t> &result_ids, const bool &is_inclusive);
-	//! Finds the minimum value of the tree
+	//! Scans the tree, starting at the current top node on the stack, and ending at upper_bound.
+	//! If upper_bound is the empty ARTKey, than there is no upper bound
+	bool Scan(const ARTKey &upper_bound, const idx_t max_count, vector<row_t> &result_ids, const bool equal);
+	//! Finds the minimum (leaf) of the current subtree
 	void FindMinimum(Node &node);
-	//! Goes to the lower bound of the tree
-	bool LowerBound(Node node, const ARTKey &key, const bool &is_inclusive);
+	//! Finds the lower bound of the ART and adds the nodes to the stack. Returns false, if the lower
+	//! bound exceeds the maximum value of the ART
+	bool LowerBound(Node &node, const ARTKey &key, const bool equal, idx_t depth);
 
 private:
-	//! Stack of iterator entries
+	//! Stack of nodes from the root to the currently active node
 	stack<IteratorEntry> nodes;
 	//! Last visited leaf
-	Leaf *last_leaf = nullptr;
+	optional_ptr<Leaf> last_leaf = nullptr;
 
-	//! Go to the next node
+	//! Goes to the next leaf in the ART and sets it as last_leaf,
+	//! returns false if there is no next leaf
 	bool Next();
-	//! Push part of the key to the current key
-	void PushKey(const Node &node, const uint8_t byte);
-	//! Pop node from the stack of iterator entries
+	//! Pop the top node from the stack of iterator entries and adjust the current key
 	void PopNode();
 };
 } // namespace duckdb

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

@@ -8,16 +8,13 @@
 
 #pragma once
 
-#include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/fixed_size_allocator.hpp"
+#include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/execution/index/art/prefix.hpp"
 
 namespace duckdb {
 
 // classes
-class Node;
-class ARTKey;
 class MetaBlockWriter;
 class MetaBlockReader;
 
@@ -28,8 +25,6 @@ class Leaf {
 public:
 	//! Number of row IDs
 	uint32_t count;
-	//! Compressed path (prefix)
-	Prefix prefix;
 	union {
 		//! The pointer to the head of the list of leaf segments
 		Node ptr;
@@ -38,13 +33,10 @@ public:
 	} row_ids;
 
 public:
-	//! Get a new leaf node, might cause a new buffer allocation, and initializes a leaf holding one
-	//! row ID and a prefix starting at depth
-	static Leaf &New(ART &art, Node &node, const ARTKey &key, const uint32_t depth, const row_t row_id);
-	//! Get a new leaf node, might cause a new buffer allocation, and initializes a leaf holding
-	//! n_row_ids row IDs and a prefix starting at depth
-	static Leaf &New(ART &art, Node &node, const ARTKey &key, const uint32_t depth, const row_t *row_ids,
-	                 const idx_t count);
+	//! Get a new leaf node, might cause a new buffer allocation, and initializes a leaf holding one row ID
+	static Leaf &New(ART &art, Node &node, const row_t row_id);
+	//! Get a new leaf node, might cause a new buffer allocation, and initializes a leaf holding n_row_ids row IDs
+	static Leaf &New(ART &art, Node &node, const row_t *row_ids, const idx_t count);
 	//! Free the leaf
 	static void Free(ART &art, Node &node);
 	//! Get a reference to the leaf
@@ -72,7 +64,7 @@ public:
 	//! and sets the ptr to point to the segment containing the row ID
 	uint32_t FindRowId(const ART &art, Node &ptr, const row_t row_id) const;
 
-	//! Returns the string representation of a leaf
+	//! Returns the string representation of the node, or only traverses and verifies the node and its subtree
 	string VerifyAndToString(const ART &art, const bool only_verify) const;
 
 	//! Serialize this leaf

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

@@ -15,7 +15,7 @@ namespace duckdb {
 
 // classes
 enum class NType : uint8_t {
-	PREFIX_SEGMENT = 1,
+	PREFIX = 1,
 	LEAF_SEGMENT = 2,
 	LEAF = 3,
 	NODE_4 = 4,
@@ -38,11 +38,6 @@ struct ARTFlags;
 //! The remaining bytes are the position in the respective ART buffer.
 class Node : public SwizzleablePointer {
 public:
-	// constants (this allows testing performance with different ART node sizes)
-
-	//! Node prefixes (NOTE: this should always hold: PREFIX_SEGMENT_SIZE >= PREFIX_INLINE_BYTES)
-	static constexpr uint32_t PREFIX_INLINE_BYTES = 8;
-	static constexpr uint32_t PREFIX_SEGMENT_SIZE = 32;
 	//! Node thresholds
 	static constexpr uint8_t NODE_48_SHRINK_THRESHOLD = 12;
 	static constexpr uint8_t NODE_256_SHRINK_THRESHOLD = 36;
@@ -54,6 +49,7 @@ public:
 	//! Other constants
 	static constexpr uint8_t EMPTY_MARKER = 48;
 	static constexpr uint32_t LEAF_SEGMENT_SIZE = 8;
+	static constexpr uint8_t PREFIX_SIZE = 15;
 
 public:
 	//! Constructs an empty ARTNode
@@ -73,7 +69,7 @@ public:
 	//! Retrieve the node type from the leftmost byte
 	inline NType DecodeARTNodeType() const {
 		D_ASSERT(!IsSwizzled());
-		D_ASSERT(type >= (uint8_t)NType::PREFIX_SEGMENT);
+		D_ASSERT(type >= (uint8_t)NType::PREFIX);
 		D_ASSERT(type <= (uint8_t)NType::NODE_256);
 		return NType(type);
 	}
@@ -91,7 +87,7 @@ public:
 	//! Insert the child node at byte
 	static void InsertChild(ART &art, Node &node, const uint8_t byte, const Node child);
 	//! Delete the child node at the respective byte
-	static void DeleteChild(ART &art, Node &node, const uint8_t byte);
+	static void DeleteChild(ART &art, Node &node, Node &prefix, const uint8_t byte);
 
 	//! Get the child for the respective byte in the node
 	optional_ptr<Node> GetChild(ART &art, const uint8_t byte) const;
@@ -107,8 +103,6 @@ public:
 	string VerifyAndToString(ART &art, const bool only_verify);
 	//! Returns the capacity of the node
 	idx_t GetCapacity() const;
-	//! Returns a pointer to the prefix of the node
-	Prefix &GetPrefix(ART &art);
 	//! Returns the matching node type for a given count
 	static NType GetARTNodeTypeByCount(const idx_t count);
 	//! Get references to the different allocators

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

@@ -8,10 +8,9 @@
 
 #pragma once
 
-#include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/fixed_size_allocator.hpp"
+#include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/execution/index/art/prefix.hpp"
 
 namespace duckdb {
 
@@ -20,8 +19,6 @@ class Node16 {
 public:
 	//! Number of non-null children
 	uint8_t count;
-	//! Compressed path (prefix)
-	Prefix prefix;
 	//! Array containing all partial key bytes
 	uint8_t key[Node::NODE_16_CAPACITY];
 	//! ART node pointers to the child nodes
@@ -57,10 +54,10 @@ public:
 	//! Get the first child that is greater or equal to the specific byte
 	optional_ptr<Node> GetNextChild(uint8_t &byte);
 
-	//! Serialize an ART node
+	//! Serialize this node
 	BlockPointer Serialize(ART &art, MetaBlockWriter &writer);
 	//! Deserialize this node
-	void Deserialize(ART &art, MetaBlockReader &reader);
+	void Deserialize(MetaBlockReader &reader);
 
 	//! Vacuum the children of the node
 	void Vacuum(ART &art, const ARTFlags &flags);

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

@@ -8,10 +8,9 @@
 
 #pragma once
 
-#include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/fixed_size_allocator.hpp"
+#include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/execution/index/art/prefix.hpp"
 
 namespace duckdb {
 
@@ -20,8 +19,6 @@ class Node256 {
 public:
 	//! Number of non-null children
 	uint16_t count;
-	//! Compressed path (prefix)
-	Prefix prefix;
 	//! ART node pointers to the child nodes
 	Node children[Node::NODE_256_CAPACITY];
 
@@ -60,10 +57,10 @@ public:
 	//! Get the first child that is greater or equal to the specific byte
 	optional_ptr<Node> GetNextChild(uint8_t &byte);
 
-	//! Serialize an ART node
+	//! Serialize this node
 	BlockPointer Serialize(ART &art, MetaBlockWriter &writer);
 	//! Deserialize this node
-	void Deserialize(ART &art, MetaBlockReader &reader);
+	void Deserialize(MetaBlockReader &reader);
 
 	//! Vacuum the children of the node
 	void Vacuum(ART &art, const ARTFlags &flags);

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

@@ -8,10 +8,9 @@
 
 #pragma once
 
-#include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/fixed_size_allocator.hpp"
+#include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/execution/index/art/prefix.hpp"
 
 namespace duckdb {
 
@@ -20,8 +19,6 @@ class Node4 {
 public:
 	//! Number of non-null children
 	uint8_t count;
-	//! Compressed path (prefix)
-	Prefix prefix;
 	//! Array containing all partial key bytes
 	uint8_t key[Node::NODE_4_CAPACITY];
 	//! ART node pointers to the child nodes
@@ -39,13 +36,13 @@ public:
 	//! Initializes all fields of the node while shrinking a Node16 to a Node4
 	static Node4 &ShrinkNode16(ART &art, Node &node4, Node &node16);
 
-	//! Initializes a merge by incrementing the buffer IDs of the node
+	//! Initializes a merge by incrementing the buffer IDs of the child nodes
 	void InitializeMerge(ART &art, const ARTFlags &flags);
 
 	//! Insert a child node at byte
 	static void InsertChild(ART &art, Node &node, const uint8_t byte, const Node child);
 	//! Delete the child node at the respective byte
-	static void DeleteChild(ART &art, Node &node, const uint8_t byte);
+	static void DeleteChild(ART &art, Node &node, Node &prefix, const uint8_t byte);
 
 	//! Replace the child node at the respective byte
 	void ReplaceChild(const uint8_t byte, const Node child);
@@ -55,10 +52,10 @@ public:
 	//! Get the first child that is greater or equal to the specific byte
 	optional_ptr<Node> GetNextChild(uint8_t &byte);
 
-	//! Serialize an ART node
+	//! Serialize this node
 	BlockPointer Serialize(ART &art, MetaBlockWriter &writer);
 	//! Deserialize this node
-	void Deserialize(ART &art, MetaBlockReader &reader);
+	void Deserialize(MetaBlockReader &reader);
 
 	//! Vacuum the children of the node
 	void Vacuum(ART &art, const ARTFlags &flags);

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

@@ -8,10 +8,9 @@
 
 #pragma once
 
-#include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/fixed_size_allocator.hpp"
+#include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/execution/index/art/node.hpp"
-#include "duckdb/execution/index/art/prefix.hpp"
 
 namespace duckdb {
 
@@ -21,8 +20,6 @@ class Node48 {
 public:
 	//! Number of non-null children
 	uint8_t count;
-	//! Compressed path (prefix)
-	Prefix prefix;
 	//! Array containing all possible partial key bytes, those not set have an EMPTY_MARKER
 	uint8_t child_index[Node::NODE_256_CAPACITY];
 	//! ART node pointers to the child nodes
@@ -67,10 +64,10 @@ public:
 	//! Get the first child that is greater or equal to the specific byte
 	optional_ptr<Node> GetNextChild(uint8_t &byte);
 
-	//! Serialize an ART node
+	//! Serialize this node
 	BlockPointer Serialize(ART &art, MetaBlockWriter &writer);
 	//! Deserialize this node
-	void Deserialize(ART &art, MetaBlockReader &reader);
+	void Deserialize(MetaBlockReader &reader);
 
 	//! Vacuum the children of the node
 	void Vacuum(ART &art, const ARTFlags &flags);

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/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) {
+		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 child node(s)
+	inline void InitializeMerge(ART &art, const ARTFlags &flags) {
+		ptr.InitializeMerge(art, 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
+	string VerifyAndToString(ART &art, 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
+	BlockPointer Serialize(ART &art, MetaBlockWriter &writer);
+	//! Deserialize this node
+	void Deserialize(MetaBlockReader &reader);
 
-	//! Vacuum the prefix segments of a prefix, if not inlined
-	void Vacuum(ART &art);
+	//! Vacuum the child of the node
+	inline void Vacuum(ART &art, const ARTFlags &flags) {
+		Node::Vacuum(art, ptr, 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);
 };
 
 } // namespace duckdb

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;
@@ -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_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;

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);
 

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/persistent/base_csv_reader.hpp

@@ -37,7 +37,7 @@ class BaseCSVReader {
 public:
 	BaseCSVReader(ClientContext &context, BufferedCSVReaderOptions options,
 	              const vector<LogicalType> &requested_types = vector<LogicalType>());
-	~BaseCSVReader();
+	virtual ~BaseCSVReader();
 
 	ClientContext &context;
 	FileSystem &fs;
@@ -75,7 +75,7 @@ public:
 	}
 
 	//! Get the 1-indexed global line number for the given local error line
-	virtual idx_t GetLineError(idx_t line_error, idx_t buffer_idx) {
+	virtual idx_t GetLineError(idx_t line_error, idx_t buffer_idx, bool stop_at_first = true) {
 		return line_error + 1;
 	};
 

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

@@ -18,11 +18,12 @@ public:
 	bool CanItGetLine(idx_t file_idx, idx_t batch_idx);
 
 	//! Return the 1-indexed line number
-	idx_t GetLine(idx_t batch_idx, idx_t line_error = 0, idx_t file_idx = 0, idx_t cur_start = 0, bool verify = true);
+	idx_t GetLine(idx_t batch_idx, idx_t line_error = 0, idx_t file_idx = 0, idx_t cur_start = 0, bool verify = true,
+	              bool stop_at_first = true);
 	//! Verify if the CSV File was read correctly from [0,batch_idx] batches.
 	void Verify(idx_t file_idx, idx_t batch_idx, idx_t cur_first_pos);
-	//! Lines read per batch, <batch_index,count>
-	unordered_map<idx_t, idx_t> lines_read;
+	//! Lines read per batch, <file_index, <batch_index, count>>
+	vector<unordered_map<idx_t, idx_t>> lines_read;
 	//! Set of batches that have been initialized but are not yet finished.
 	vector<set<idx_t>> current_batches;
 	//! Pointer to CSV Reader Mutex

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

@@ -55,6 +55,14 @@ struct BufferedCSVReaderOptions {
 	bool header = false;
 	//! Whether or not we should ignore InvalidInput errors
 	bool ignore_errors = false;
+	//! Rejects table name
+	string rejects_table_name;
+	//! Rejects table entry limit (0 = no limit)
+	idx_t rejects_limit = 0;
+	//! Columns to use as recovery key for rejected rows when reading with ignore_errors = true
+	vector<string> rejects_recovery_columns;
+	//! Index of the recovery columns
+	vector<idx_t> rejects_recovery_column_ids;
 	//! Expected number of columns
 	idx_t num_cols = 0;
 	//! Number of samples to buffer
@@ -155,7 +163,6 @@ struct BufferedCSVReaderOptions {
 	//! set - argument(s) to the option
 	//! expected_names - names expected if the option is "columns"
 	void SetReadOption(const string &loption, const Value &value, vector<string> &expected_names);
-
 	void SetWriteOption(const string &loption, const Value &value);
 	void SetDateFormat(LogicalTypeId type, const string &format, bool read_format);