duckdb 1.0.1-dev21.0 → 1.0.1-dev27.0

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

@@ -13,77 +13,116 @@
 
 namespace duckdb {
 
-// classes
 class ARTKey;
 
-//! 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 a prefix node or another Node.
+//! Prefix is a wrapper class to access a prefix.
+//! The prefix contains up to the ART's prefix size bytes and an additional byte for the count.
+//! It also contains a Node pointer to a child node.
 class Prefix {
 public:
-	//! Delete copy constructors, as any Prefix can never own its memory
-	Prefix(const Prefix &) = delete;
-	Prefix &operator=(const Prefix &) = delete;
+	static constexpr NType PREFIX = NType::PREFIX;
 
-	//! Up to PREFIX_SIZE bytes of prefix data and the count
-	uint8_t data[Node::PREFIX_SIZE + 1];
-	//! A pointer to the next Node
-	Node ptr;
+	static constexpr uint8_t ROW_ID_SIZE = sizeof(row_t);
+	static constexpr uint8_t ROW_ID_COUNT = ROW_ID_SIZE - 1;
+	static constexpr uint8_t DEPRECATED_COUNT = 15;
+	static constexpr uint8_t METADATA_SIZE = sizeof(Node) + 1;
 
 public:
-	//! 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, const Node &next = Node());
-	//! 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);
+	Prefix() = delete;
+	Prefix(const ART &art, const Node ptr_p, const bool is_mutable = false, const bool set_in_memory = false);
+	Prefix(unsafe_unique_ptr<FixedSizeAllocator> &allocator, const Node ptr_p, const idx_t count);
+
+	data_ptr_t data;
+	Node *ptr;
+	bool in_memory;
 
-	//! 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);
-
-	//! 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<const Node> &prefix_node, const ARTKey &key, idx_t &depth);
-	//! 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 TraverseMutable(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. This function aids in merging Nodes, and, therefore,
-	//! the nodes are not const
-	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 = Node::Ref<const Prefix>(art, prefix_node, NType::PREFIX);
-		D_ASSERT(position < Node::PREFIX_SIZE);
-		D_ASSERT(position < prefix.data[Node::PREFIX_SIZE]);
-		return prefix.data[position];
+public:
+	static inline uint8_t Count(const ART &art) {
+		return art.prefix_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);
+	static idx_t GetMismatchWithOther(const Prefix &l_prefix, const Prefix &r_prefix, const idx_t max_count);
+	static idx_t GetMismatchWithKey(ART &art, const Node &node, const ARTKey &key, idx_t &depth);
+	static uint8_t GetByte(const ART &art, const Node &node, const uint8_t pos);
+
+public:
+	//! Get a new list of prefix nodes. The node reference holds the last prefix of the list.
+	static void New(ART &art, reference<Node> &ref, const ARTKey &key, const idx_t depth, idx_t count);
+
+	//! Free the prefix and its child.
+	static void Free(ART &art, Node &node);
+
+	//! Initializes a merge by incrementing the buffer ID of the prefix and its child.
+	static void InitializeMerge(ART &art, Node &node, const unsafe_vector<idx_t> &upper_bounds);
+
+	//! Concatenates parent -> byte -> child. Special-handling, if
+	//! 1. the byte was in a gate node.
+	//! 2. the byte was in PREFIX_INLINED.
+	static void Concat(ART &art, Node &parent, uint8_t byte, const GateStatus old_status, const Node &child,
+	                   const GateStatus status);
+
+	//! Traverse a prefix and a key until
+	//! 1. a non-prefix node.
+	//! 2. a mismatching byte.
+	//! Early-out, if the next prefix is a gate node.
+	static idx_t Traverse(ART &art, reference<const Node> &node, const ARTKey &key, idx_t &depth);
+	static idx_t TraverseMutable(ART &art, reference<Node> &node, const ARTKey &key, idx_t &depth);
+
+	//! Traverse two prefixes to find
+	//! 1. that they match.
+	//! 2. that they mismatch.
+	//! 3. that one prefix contains the other prefix.
+	static bool Traverse(ART &art, reference<Node> &l_node, reference<Node> &r_node, idx_t &pos,
+	                     const GateStatus status);
+
+	//! Removes up to pos bytes from the prefix.
+	//! Shifts all subsequent bytes by pos. Frees empty nodes.
+	static void Reduce(ART &art, Node &node, const idx_t pos);
+	//! Splits the prefix at pos.
+	//! prefix_node points to the node that replaces the split byte.
+	//! child_node points to the remaining node after the split.
+	//! Returns INSIDE, if a gate node was freed, else OUTSIDE.
+	static GateStatus Split(ART &art, reference<Node> &node, Node &child, const uint8_t pos);
+
+	//! Insert a key into a prefix.
+	static bool Insert(ART &art, Node &node, const ARTKey &key, idx_t depth, const ARTKey &row_id,
+	                   const GateStatus status);
 
 	//! Returns the string representation of the node, or only traverses and verifies the node and its subtree
 	static string VerifyAndToString(ART &art, const Node &node, const bool only_verify);
+	//! Count the number of prefixes.
+	static void VerifyAllocations(ART &art, const Node &node, unordered_map<uint8_t, idx_t> &node_counts);
+
+	//! Vacuum the child of the node.
+	static void Vacuum(ART &art, Node &node, const unordered_set<uint8_t> &indexes);
+
+	//! Transform the child of the node.
+	static void TransformToDeprecated(ART &art, Node &node, unsafe_unique_ptr<FixedSizeAllocator> &allocator);
+
+private:
+	static Prefix NewInternal(ART &art, Node &node, const data_ptr_t data, const uint8_t count, const idx_t offset,
+	                          const NType type);
+
+	static Prefix GetTail(ART &art, const Node &node);
+
+	static void ConcatGate(ART &art, Node &parent, uint8_t byte, const Node &child);
+	static void ConcatChildIsGate(ART &art, Node &parent, uint8_t byte, const Node &child);
 
-	//! Vacuum the child of the node
-	static void Vacuum(ART &art, Node &node, const ARTFlags &flags);
+	Prefix Append(ART &art, const uint8_t byte);
+	void Append(ART &art, Node other);
+	Prefix TransformToDeprecatedAppend(ART &art, unsafe_unique_ptr<FixedSizeAllocator> &allocator, uint8_t byte);
 
 private:
-	//! 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);
+	template <class F, class NODE>
+	static void Iterator(ART &art, reference<NODE> &ref, const bool exit_gate, const bool is_mutable, F &&lambda) {
+		while (ref.get().HasMetadata() && ref.get().GetType() == PREFIX) {
+			Prefix prefix(art, ref, is_mutable);
+			lambda(prefix);
+
+			ref = *prefix.ptr;
+			if (exit_gate && ref.get().GetGateStatus() == GateStatus::GATE_SET) {
+				break;
+			}
+		}
+	}
 };
 } // namespace duckdb

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

@@ -106,16 +106,21 @@ public: // Index interface
 	//! 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
+	//! 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
+	//! Obtains a lock and calls VerifyAndToString.
 	string VerifyAndToString(const bool only_verify);
 
+	//! Ensures that the node allocation counts match the node counts.
+	virtual void VerifyAllocations(IndexLock &state) = 0;
+	//! Obtains a lock and calls VerifyAllocations.
+	void VerifyAllocations();
+
 	//! 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);
+	//! Returns index storage serialization information.
+	virtual IndexStorageInfo GetStorageInfo(const case_insensitive_map_t<Value> &options, const bool to_wal);
 
 	//! Execute the index expressions on an input chunk
 	void ExecuteExpressions(DataChunk &input, DataChunk &result);

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

@@ -42,17 +42,57 @@ public:
 	IndexPointer New();
 	//! Free the segment of the IndexPointer
 	void Free(const IndexPointer ptr);
-	//! Returns a pointer of type T to a segment. If dirty is false, then T should be a const class
+
+	//! Returns a pointer of type T to a segment. If dirty is false, then T must be a const class.
 	template <class T>
-	inline T *Get(const IndexPointer ptr, const bool dirty = true) {
+	inline unsafe_optional_ptr<T> Get(const IndexPointer ptr, const bool dirty = true) {
 		return (T *)Get(ptr, dirty);
 	}
 
+	//! Returns the data_ptr_t to a segment, and sets the dirty flag of the buffer containing that segment.
+	inline data_ptr_t Get(const IndexPointer ptr, const bool dirty = true) {
+		D_ASSERT(ptr.GetOffset() < available_segments_per_buffer);
+		D_ASSERT(buffers.find(ptr.GetBufferId()) != buffers.end());
+
+		auto &buffer = buffers.find(ptr.GetBufferId())->second;
+		auto buffer_ptr = buffer.Get(dirty);
+		return buffer_ptr + ptr.GetOffset() * segment_size + bitmask_offset;
+	}
+
+	//! Returns a pointer of type T to a segment, or nullptr, if the buffer is not in memory.
+	template <class T>
+	inline unsafe_optional_ptr<T> GetIfLoaded(const IndexPointer ptr) {
+		return (T *)GetIfLoaded(ptr);
+	}
+
+	//! Returns the data_ptr_t to a segment, or nullptr, if the buffer is not in memory.
+	inline data_ptr_t GetIfLoaded(const IndexPointer ptr) {
+		D_ASSERT(ptr.GetOffset() < available_segments_per_buffer);
+		D_ASSERT(buffers.find(ptr.GetBufferId()) != buffers.end());
+
+		auto &buffer = buffers.find(ptr.GetBufferId())->second;
+		if (!buffer.InMemory()) {
+			return nullptr;
+		}
+
+		auto buffer_ptr = buffer.Get();
+		auto raw_ptr = buffer_ptr + ptr.GetOffset() * segment_size + bitmask_offset;
+		return raw_ptr;
+	}
+
 	//! Resets the allocator, e.g., during 'DELETE FROM table'
 	void Reset();
 
 	//! Returns the in-memory size in bytes
 	idx_t GetInMemorySize() const;
+	//! Returns the segment size.
+	inline idx_t GetSegmentSize() const {
+		return segment_size;
+	}
+	//! Returns the total segment count.
+	inline idx_t GetSegmentCount() const {
+		return total_segment_count;
+	}
 
 	//! Returns the upper bound of the available buffer IDs, i.e., upper_bound > max_buffer_id
 	idx_t GetUpperBoundBufferId() const;
@@ -83,6 +123,12 @@ public:
 	void Init(const FixedSizeAllocatorInfo &info);
 	//! Deserializes all metadata of older storage files
 	void Deserialize(MetadataManager &metadata_manager, const BlockPointer &block_pointer);
+	//! Removes empty buffers.
+	void RemoveEmptyBuffers();
+	//! Returns true, if the allocator does not contain any segments.
+	inline bool IsEmpty() {
+		return total_segment_count == 0;
+	}
 
 private:
 	//! Allocation size of one segment in a buffer
@@ -109,14 +155,6 @@ private:
 	unordered_set<idx_t> vacuum_buffers;
 
 private:
-	//! Returns the data_ptr_t to a segment, and sets the dirty flag of the buffer containing that segment
-	inline data_ptr_t Get(const IndexPointer ptr, const bool dirty = true) {
-		D_ASSERT(ptr.GetOffset() < available_segments_per_buffer);
-		D_ASSERT(buffers.find(ptr.GetBufferId()) != buffers.end());
-		auto &buffer = buffers.find(ptr.GetBufferId())->second;
-		auto buffer_ptr = buffer.Get(dirty);
-		return buffer_ptr + ptr.GetOffset() * segment_size + bitmask_offset;
-	}
 	//! Returns an available buffer id
 	idx_t GetAvailableBufferId() const;
 };

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

@@ -100,8 +100,6 @@ private:
 	shared_ptr<BlockHandle> block_handle;
 
 private:
-	//! Returns the maximum non-free offset in a bitmask
-	uint32_t GetMaxOffset(const idx_t available_segments_per_buffer);
 	//! Sets all uninitialized regions of a buffer in the respective partial block allocation
 	void SetUninitializedRegions(PartialBlockForIndex &p_block_for_index, const idx_t segment_size, const idx_t offset,
 	                             const idx_t bitmask_offset);

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

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include "duckdb/common/numeric_utils.hpp"
 #include "duckdb/common/typedefs.hpp"
 
 namespace duckdb {
@@ -27,7 +28,7 @@ public:
 	IndexPointer() : data(0) {};
 	//! Constructs an in-memory IndexPointer with a buffer ID and an offset
 	IndexPointer(const uint32_t buffer_id, const uint32_t offset) : data(0) {
-		auto shifted_offset = ((idx_t)offset) << SHIFT_OFFSET;
+		auto shifted_offset = UnsafeNumericCast<idx_t>(offset) << SHIFT_OFFSET;
 		data += shifted_offset;
 		data += buffer_id;
 	};
@@ -52,7 +53,8 @@ public:
 	}
 	//! Set metadata (zero to 7th bit)
 	inline void SetMetadata(const uint8_t metadata) {
-		data += (idx_t)metadata << SHIFT_METADATA;
+		data &= ~AND_METADATA;
+		data |= UnsafeNumericCast<idx_t>(metadata) << SHIFT_METADATA;
 	}
 
 	//! Get the offset (8th to 23rd bit)

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

@@ -8,17 +8,16 @@
 
 #pragma once
 
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/radix_partitioning.hpp"
 #include "duckdb/common/types/column/column_data_consumer.hpp"
+#include "duckdb/common/types/column/partitioned_column_data.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/common/types/null_value.hpp"
+#include "duckdb/common/types/row/partitioned_tuple_data.hpp"
 #include "duckdb/common/types/row/tuple_data_iterator.hpp"
 #include "duckdb/common/types/row/tuple_data_layout.hpp"
 #include "duckdb/common/types/vector.hpp"
 #include "duckdb/execution/aggregate_hashtable.hpp"
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/storage/storage_info.hpp"
+#include "duckdb/execution/ht_entry.hpp"
 
 namespace duckdb {
 
@@ -60,25 +59,34 @@ class JoinHashTable {
 public:
 	using ValidityBytes = TemplatedValidityMask<uint8_t>;
 
+	//! only compare salts with the ht entries if the capacity is larger than 8192 so
+	//! that it does not fit into the CPU cache
+	static constexpr const idx_t USE_SALT_THRESHOLD = 8192;
+
 	//! Scan structure that can be used to resume scans, as a single probe can
 	//! return 1024*N values (where N is the size of the HT). This is
 	//! returned by the JoinHashTable::Scan function and can be used to resume a
 	//! probe.
 	struct ScanStructure {
 		TupleDataChunkState &key_state;
+		//! Directly point to the entry in the hash table
 		Vector pointers;
 		idx_t count;
 		SelectionVector sel_vector;
+		SelectionVector chain_match_sel_vector;
+		SelectionVector chain_no_match_sel_vector;
+
 		// whether or not the given tuple has found a match
 		unsafe_unique_array<bool> found_match;
 		JoinHashTable &ht;
 		bool finished;
+		bool is_null;
 
 		explicit ScanStructure(JoinHashTable &ht, TupleDataChunkState &key_state);
 		//! Get the next batch of data from the scan structure
 		void Next(DataChunk &keys, DataChunk &left, DataChunk &result);
 		//! Are pointer chains all pointing to NULL?
-		bool PointersExhausted();
+		bool PointersExhausted() const;
 
 	private:
 		//! Next operator for the inner join
@@ -87,6 +95,8 @@ public:
 		void NextSemiJoin(DataChunk &keys, DataChunk &left, DataChunk &result);
 		//! Next operator for the anti join
 		void NextAntiJoin(DataChunk &keys, DataChunk &left, DataChunk &result);
+		//! Next operator for the RIGHT semi and anti join
+		void NextRightSemiOrAntiJoin(DataChunk &keys);
 		//! Next operator for the left outer join
 		void NextLeftJoin(DataChunk &keys, DataChunk &left, DataChunk &result);
 		//! Next operator for the mark join
@@ -105,7 +115,6 @@ public:
 		idx_t ScanInnerJoin(DataChunk &keys, SelectionVector &result_vector);
 
 	public:
-		void InitializeSelectionVector(const SelectionVector *&current_sel);
 		void AdvancePointers();
 		void AdvancePointers(const SelectionVector &sel, idx_t sel_count);
 		void GatherResult(Vector &result, const SelectionVector &result_vector, const SelectionVector &sel_vector,
@@ -115,8 +124,41 @@ public:
 	};
 
 public:
-	JoinHashTable(BufferManager &buffer_manager, const vector<JoinCondition> &conditions,
-	              vector<LogicalType> build_types, JoinType type, const vector<idx_t> &output_columns);
+	struct SharedState {
+
+		SharedState();
+
+		// The ptrs to the row to which a key should be inserted into during building
+		// or matched against during probing
+		Vector rhs_row_locations;
+
+		SelectionVector salt_match_sel;
+		SelectionVector key_no_match_sel;
+	};
+
+	struct ProbeState : SharedState {
+
+		ProbeState();
+
+		Vector salt_v;
+		Vector ht_offsets_v;
+		Vector ht_offsets_dense_v;
+
+		SelectionVector non_empty_sel;
+	};
+
+	struct InsertState : SharedState {
+		explicit InsertState(const JoinHashTable &ht);
+		/// Because of the index hick up
+		SelectionVector remaining_sel;
+		SelectionVector key_match_sel;
+
+		DataChunk lhs_data;
+		TupleDataChunkState chunk_state;
+	};
+
+	JoinHashTable(ClientContext &context, const vector<JoinCondition> &conditions, vector<LogicalType> build_types,
+	              JoinType type, const vector<idx_t> &output_columns);
 	~JoinHashTable();
 
 	//! Add the given data to the HT
@@ -132,13 +174,13 @@ public:
 	//! ever called.
 	void Finalize(idx_t chunk_idx_from, idx_t chunk_idx_to, bool parallel);
 	//! Probe the HT with the given input chunk, resulting in the given result
-	unique_ptr<ScanStructure> Probe(DataChunk &keys, TupleDataChunkState &key_state,
-	                                Vector *precomputed_hashes = nullptr);
+	void Probe(ScanStructure &scan_structure, DataChunk &keys, TupleDataChunkState &key_state, ProbeState &probe_state,
+	           optional_ptr<Vector> precomputed_hashes = nullptr);
 	//! Scan the HT to construct the full outer join result
-	void ScanFullOuter(JoinHTScanState &state, Vector &addresses, DataChunk &result);
+	void ScanFullOuter(JoinHTScanState &state, Vector &addresses, DataChunk &result) const;
 
 	//! Fill the pointer with all the addresses from the hashtable for full scan
-	idx_t FillWithHTOffsets(JoinHTScanState &state, Vector &addresses);
+	static idx_t FillWithHTOffsets(JoinHTScanState &state, Vector &addresses);
 
 	idx_t Count() const {
 		return data_collection->Count();
@@ -154,6 +196,9 @@ public:
 	TupleDataCollection &GetDataCollection() {
 		return *data_collection;
 	}
+	bool NullValuesAreEqual(idx_t col_idx) const {
+		return null_values_are_equal[col_idx];
+	}
 
 	//! BufferManager
 	BufferManager &buffer_manager;
@@ -167,18 +212,38 @@ public:
 	vector<LogicalType> build_types;
 	//! Positions of the columns that need to output
 	const vector<idx_t> &output_columns;
-	//! The comparison predicates
-	vector<ExpressionType> predicates;
+	//! The comparison predicates that only contain equality predicates
+	vector<ExpressionType> equality_predicates;
+	//! The comparison predicates that contain non-equality predicates
+	vector<ExpressionType> non_equality_predicates;
+
+	//! The column indices of the equality predicates to be used to compare the rows
+	vector<column_t> equality_predicate_columns;
+	//! The column indices of the non-equality predicates to be used to compare the rows
+	vector<column_t> non_equality_predicate_columns;
 	//! Data column layout
 	TupleDataLayout layout;
-	//! Efficiently matches rows
-	RowMatcher row_matcher;
-	RowMatcher row_matcher_no_match_sel;
+	//! Matches the equal condition rows during the build phase of the hash join to prevent
+	//! duplicates in a list because of hash-collisions
+	RowMatcher row_matcher_build;
+	//! Efficiently matches the non-equi rows during the probing phase, only there if non_equality_predicates is not
+	//! empty
+	unique_ptr<RowMatcher> row_matcher_probe;
+	//! Matches the same rows as the row_matcher, but also returns a vector for no matches
+	unique_ptr<RowMatcher> row_matcher_probe_no_match_sel;
+	//! Is true if there are predicates that are not equality predicates and we need to use the matchers during probing
+	bool needs_chain_matcher;
+
+	//! If there is more than one element in the chain, we need to scan the next elements of the chain
+	bool chains_longer_than_one;
+
+	//! The capacity of the HT. Is the same as hash_map.GetSize() / sizeof(ht_entry_t)
+	idx_t capacity = DConstants::INVALID_INDEX;
 	//! The size of an entry as stored in the HashTable
 	idx_t entry_size;
 	//! The total tuple size
 	idx_t tuple_size;
-	//! Next pointer offset in tuple
+	//! Next pointer offset in tuple, also used for the position of the hash, which then gets overwritten by the pointer
 	idx_t pointer_offset;
 	//! A constant false column for initialising right outer joins
 	Vector vfound;
@@ -189,7 +254,9 @@ public:
 	//! Whether or not any of the key elements contain NULL
 	bool has_null;
 	//! Bitmask for getting relevant bits from the hashes to determine the position
-	uint64_t bitmask;
+	uint64_t bitmask = DConstants::INVALID_INDEX;
+	//! Whether or not we error on multiple rows found per match in a SINGLE join
+	bool single_join_error_on_multiple_rows = true;
 
 	struct {
 		mutex mj_lock;
@@ -209,18 +276,23 @@ public:
 	} correlated_mark_join_info;
 
 private:
-	unique_ptr<ScanStructure> InitializeScanStructure(DataChunk &keys, TupleDataChunkState &key_state,
-	                                                  const SelectionVector *&current_sel);
+	void InitializeScanStructure(ScanStructure &scan_structure, DataChunk &keys, TupleDataChunkState &key_state,
+	                             const SelectionVector *&current_sel);
 	void Hash(DataChunk &keys, const SelectionVector &sel, idx_t count, Vector &hashes);
 
-	//! Apply a bitmask to the hashes
-	void ApplyBitmask(Vector &hashes, idx_t count);
-	void ApplyBitmask(Vector &hashes, const SelectionVector &sel, idx_t count, Vector &pointers);
+	bool UseSalt() const;
 
-private:
-	//! Insert the given set of locations into the HT with the given set of hashes
-	void InsertHashes(Vector &hashes, idx_t count, data_ptr_t key_locations[], bool parallel);
+	//! Gets a pointer to the entry in the HT for each of the hashes_v using linear probing. Will update the
+	//! key_match_sel vector and the count argument to the number and position of the matches
+	void GetRowPointers(DataChunk &keys, TupleDataChunkState &key_state, ProbeState &state, Vector &hashes_v,
+	                    const SelectionVector &sel, idx_t &count, Vector &pointers_result_v,
+	                    SelectionVector &match_sel);
 
+private:
+	//! Insert the given set of locations into the HT with the given set of hashes_v
+	void InsertHashes(Vector &hashes_v, idx_t count, TupleDataChunkState &chunk_state, InsertState &insert_statebool,
+	                  bool parallel);
+	//! Prepares keys by filtering NULLs
 	idx_t PrepareKeys(DataChunk &keys, vector<TupleDataVectorFormat> &vector_data, const SelectionVector *&current_sel,
 	                  SelectionVector &sel, bool build_side);
 
@@ -230,10 +302,14 @@ private:
 	unique_ptr<PartitionedTupleData> sink_collection;
 	//! The DataCollection holding the main data of the hash table
 	unique_ptr<TupleDataCollection> data_collection;
+
 	//! The hash map of the HT, created after finalization
 	AllocatedData hash_map;
+	ht_entry_t *entries = nullptr;
 	//! Whether or not NULL values are considered equal in each of the comparisons
 	vector<bool> null_values_are_equal;
+	//! An empty tuple that's a "dead end", can be used to stop chains early
+	unsafe_unique_array<data_t> dead_end;
 
 	//! Copying not allowed
 	JoinHashTable(const JoinHashTable &) = delete;
@@ -245,9 +321,11 @@ public:
 	static constexpr const idx_t INITIAL_RADIX_BITS = 4;
 
 	struct ProbeSpillLocalAppendState {
+		ProbeSpillLocalAppendState() {
+		}
 		//! Local partition and append state (if partitioned)
-		PartitionedColumnData *local_partition;
-		PartitionedColumnDataAppendState *local_partition_append_state;
+		optional_ptr<PartitionedColumnData> local_partition;
+		optional_ptr<PartitionedColumnDataAppendState> local_partition_append_state;
 	};
 	//! ProbeSpill represents materialized probe-side data that could not be probed during PhysicalHashJoin::Execute
 	//! because the HashTable did not fit in memory. The ProbeSpill is not partitioned if the remaining data can be
@@ -312,15 +390,15 @@ public:
 	}
 
 	//! Get total size of HT if all partitions would be built
-	idx_t GetTotalSize(vector<unique_ptr<JoinHashTable>> &local_hts, idx_t &max_partition_size,
+	idx_t GetTotalSize(const vector<unique_ptr<JoinHashTable>> &local_hts, idx_t &max_partition_size,
 	                   idx_t &max_partition_count) const;
 	idx_t GetTotalSize(const vector<idx_t> &partition_sizes, const vector<idx_t> &partition_counts,
 	                   idx_t &max_partition_size, idx_t &max_partition_count) const;
 	//! Get the remaining size of the unbuilt partitions
-	idx_t GetRemainingSize();
+	idx_t GetRemainingSize() const;
 	//! Sets number of radix bits according to the max ht size
-	void SetRepartitionRadixBits(vector<unique_ptr<JoinHashTable>> &local_hts, const idx_t max_ht_size,
-	                             const idx_t max_partition_size, const idx_t max_partition_count);
+	void SetRepartitionRadixBits(const idx_t max_ht_size, const idx_t max_partition_size,
+	                             const idx_t max_partition_count);
 	//! Partition this HT
 	void Repartition(JoinHashTable &global_ht);
 
@@ -329,9 +407,9 @@ public:
 	//! Build HT for the next partitioned probe round
 	bool PrepareExternalFinalize(const idx_t max_ht_size);
 	//! Probe whatever we can, sink the rest into a thread-local HT
-	unique_ptr<ScanStructure> ProbeAndSpill(DataChunk &keys, TupleDataChunkState &key_state, DataChunk &payload,
-	                                        ProbeSpill &probe_spill, ProbeSpillLocalAppendState &spill_state,
-	                                        DataChunk &spill_chunk);
+	void ProbeAndSpill(ScanStructure &scan_structure, DataChunk &keys, TupleDataChunkState &key_state,
+	                   ProbeState &probe_state, DataChunk &payload, ProbeSpill &probe_spill,
+	                   ProbeSpillLocalAppendState &spill_state, DataChunk &spill_chunk);
 
 private:
 	//! The current number of radix bits used to partition