duckdb 1.4.2-dev4.0 → 1.4.3-dev0.0

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

@@ -66,6 +66,8 @@ public:
 	static void KeyDerivationFunctionSHA256(data_ptr_t user_key, idx_t user_key_size, data_ptr_t salt,
 	                                        data_ptr_t derived_key);
 	static string Base64Decode(const string &key);
+
+	//! Generate a (non-cryptographically secure) random key ID
 	static string GenerateRandomKeyID();
 
 public:

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

@@ -59,6 +59,11 @@ public:
 
 	virtual ~EncryptionUtil() {
 	}
+
+	//! Whether the EncryptionUtil supports encryption (some may only support decryption)
+	DUCKDB_API virtual bool SupportsEncryption() {
+		return true;
+	}
 };
 
 } // namespace duckdb

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

@@ -86,6 +86,8 @@ enum class BlockIteratorStateType : int8_t;
 
 enum class BlockState : uint8_t;
 
+enum class BufferedIndexReplay : uint8_t;
+
 enum class CAPIResultSetType : uint8_t;
 
 enum class CSVState : uint8_t;
@@ -528,6 +530,9 @@ const char* EnumUtil::ToChars<BlockIteratorStateType>(BlockIteratorStateType val
 template<>
 const char* EnumUtil::ToChars<BlockState>(BlockState value);
 
+template<>
+const char* EnumUtil::ToChars<BufferedIndexReplay>(BufferedIndexReplay value);
+
 template<>
 const char* EnumUtil::ToChars<CAPIResultSetType>(CAPIResultSetType value);
 
@@ -1150,6 +1155,9 @@ BlockIteratorStateType EnumUtil::FromString<BlockIteratorStateType>(const char *
 template<>
 BlockState EnumUtil::FromString<BlockState>(const char *value);
 
+template<>
+BufferedIndexReplay EnumUtil::FromString<BufferedIndexReplay>(const char *value);
+
 template<>
 CAPIResultSetType EnumUtil::FromString<CAPIResultSetType>(const char *value);
 

package/src/duckdb/src/include/duckdb/common/enums/compression_type.hpp

@@ -36,8 +36,48 @@ enum class CompressionType : uint8_t {
 	COMPRESSION_COUNT // This has to stay the last entry of the type!
 };
 
-bool CompressionTypeIsDeprecated(CompressionType compression_type,
-                                 optional_ptr<StorageManager> storage_manager = nullptr);
+struct CompressionAvailabilityResult {
+private:
+	enum class UnavailableReason : uint8_t {
+		AVAILABLE,
+		//! Introduced later, not available to this version
+		NOT_AVAILABLE_YET,
+		//! Used to be available, but isnt anymore
+		DEPRECATED
+	};
+
+public:
+	CompressionAvailabilityResult() = default;
+	static CompressionAvailabilityResult Deprecated() {
+		return CompressionAvailabilityResult(UnavailableReason::DEPRECATED);
+	}
+	static CompressionAvailabilityResult NotAvailableYet() {
+		return CompressionAvailabilityResult(UnavailableReason::NOT_AVAILABLE_YET);
+	}
+
+public:
+	bool IsAvailable() const {
+		return reason == UnavailableReason::AVAILABLE;
+	}
+	bool IsDeprecated() {
+		D_ASSERT(!IsAvailable());
+		return reason == UnavailableReason::DEPRECATED;
+	}
+	bool IsNotAvailableYet() {
+		D_ASSERT(!IsAvailable());
+		return reason == UnavailableReason::NOT_AVAILABLE_YET;
+	}
+
+private:
+	explicit CompressionAvailabilityResult(UnavailableReason reason) : reason(reason) {
+	}
+
+public:
+	UnavailableReason reason = UnavailableReason::AVAILABLE;
+};
+
+CompressionAvailabilityResult CompressionTypeIsAvailable(CompressionType compression_type,
+                                                         optional_ptr<StorageManager> storage_manager = nullptr);
 vector<string> ListCompressionTypes(void);
 CompressionType CompressionTypeFromString(const string &str);
 string CompressionTypeToString(CompressionType type);

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

@@ -11,6 +11,7 @@
 #include "duckdb/common/types.hpp"
 #include "duckdb/common/case_insensitive_map.hpp"
 #include "duckdb/common/enums/http_status_code.hpp"
+#include "duckdb/common/types/timestamp.hpp"
 #include <functional>
 
 namespace duckdb {
@@ -143,6 +144,11 @@ struct BaseRequest {
 	//! Whether or not to return failed requests (instead of throwing)
 	bool try_request = false;
 
+	// Requests will optionally contain their timings
+	bool have_request_timing = false;
+	timestamp_t request_start;
+	timestamp_t request_end;
+
 	template <class TARGET>
 	TARGET &Cast() {
 		return reinterpret_cast<TARGET &>(*this);
@@ -210,6 +216,7 @@ struct PostRequestInfo : public BaseRequest {
 class HTTPClient {
 public:
 	virtual ~HTTPClient() = default;
+	virtual void Initialize(HTTPParams &http_params) = 0;
 
 	virtual unique_ptr<HTTPResponse> Get(GetRequestInfo &info) = 0;
 	virtual unique_ptr<HTTPResponse> Put(PutRequestInfo &info) = 0;

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

@@ -76,7 +76,7 @@ public:
 	DUCKDB_API explicit operator int16_t() const;
 	DUCKDB_API explicit operator int32_t() const;
 	DUCKDB_API explicit operator int64_t() const;
-	DUCKDB_API operator uhugeint_t() const; // NOLINT: Allow implicit conversion from `hugeint_t`
+	DUCKDB_API explicit operator uhugeint_t() const;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/operator/comparison_operators.hpp

@@ -210,15 +210,4 @@ inline bool GreaterThan::Operation(const interval_t &left, const interval_t &rig
 	return Interval::GreaterThan(left, right);
 }
 
-//===--------------------------------------------------------------------===//
-// Specialized Hugeint Comparison Operators
-//===--------------------------------------------------------------------===//
-template <>
-inline bool Equals::Operation(const hugeint_t &left, const hugeint_t &right) {
-	return Hugeint::Equals(left, right);
-}
-template <>
-inline bool GreaterThan::Operation(const hugeint_t &left, const hugeint_t &right) {
-	return Hugeint::GreaterThan(left, right);
-}
 } // namespace duckdb

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

@@ -38,6 +38,8 @@ public:
 
 	void SetSeed(uint64_t seed);
 
+	void RandomData(duckdb::data_ptr_t data, duckdb::idx_t len);
+
 	static RandomEngine &Get(ClientContext &context);
 
 	mutex lock;

package/src/duckdb/src/include/duckdb/common/sort/duckdb_pdqsort.hpp

@@ -26,6 +26,7 @@ applications, and to alter it and redistribute it freely, subject to the followi
 #include "duckdb/common/helper.hpp"
 #include "duckdb/common/types.hpp"
 #include "duckdb/common/unique_ptr.hpp"
+#include "duckdb/common/operator/numeric_cast.hpp"
 
 #include <algorithm>
 #include <cstddef>

package/src/duckdb/src/include/duckdb/common/types/hugeint.hpp

@@ -129,38 +129,38 @@ public:
 	static int Sign(hugeint_t n);
 	static hugeint_t Abs(hugeint_t n);
 	// comparison operators
-	static bool Equals(hugeint_t lhs, hugeint_t rhs) {
+	static bool Equals(const hugeint_t &lhs, const hugeint_t &rhs) {
 		bool lower_equals = lhs.lower == rhs.lower;
 		bool upper_equals = lhs.upper == rhs.upper;
 		return lower_equals && upper_equals;
 	}
 
-	static bool NotEquals(hugeint_t lhs, hugeint_t rhs) {
+	static bool NotEquals(const hugeint_t &lhs, const hugeint_t &rhs) {
 		return !Equals(lhs, rhs);
 	}
 
-	static bool GreaterThan(hugeint_t lhs, hugeint_t rhs) {
+	static bool GreaterThan(const hugeint_t &lhs, const hugeint_t &rhs) {
 		bool upper_bigger = lhs.upper > rhs.upper;
 		bool upper_equal = lhs.upper == rhs.upper;
 		bool lower_bigger = lhs.lower > rhs.lower;
 		return upper_bigger || (upper_equal && lower_bigger);
 	}
 
-	static bool GreaterThanEquals(hugeint_t lhs, hugeint_t rhs) {
+	static bool GreaterThanEquals(const hugeint_t &lhs, const hugeint_t &rhs) {
 		bool upper_bigger = lhs.upper > rhs.upper;
 		bool upper_equal = lhs.upper == rhs.upper;
 		bool lower_bigger_equals = lhs.lower >= rhs.lower;
 		return upper_bigger || (upper_equal && lower_bigger_equals);
 	}
 
-	static bool LessThan(hugeint_t lhs, hugeint_t rhs) {
+	static bool LessThan(const hugeint_t &lhs, const hugeint_t &rhs) {
 		bool upper_smaller = lhs.upper < rhs.upper;
 		bool upper_equal = lhs.upper == rhs.upper;
 		bool lower_smaller = lhs.lower < rhs.lower;
 		return upper_smaller || (upper_equal && lower_smaller);
 	}
 
-	static bool LessThanEquals(hugeint_t lhs, hugeint_t rhs) {
+	static bool LessThanEquals(const hugeint_t &lhs, const hugeint_t &rhs) {
 		bool upper_smaller = lhs.upper < rhs.upper;
 		bool upper_equal = lhs.upper == rhs.upper;
 		bool lower_smaller_equals = lhs.lower <= rhs.lower;

package/src/duckdb/src/include/duckdb/common/types/row/block_iterator.hpp

@@ -23,64 +23,98 @@ enum class BlockIteratorStateType : int8_t {
 	EXTERNAL,
 };
 
-BlockIteratorStateType GetBlockIteratorStateType(const bool &external);
+static BlockIteratorStateType GetBlockIteratorStateType(const bool &external) {
+	return external ? BlockIteratorStateType::EXTERNAL : BlockIteratorStateType::IN_MEMORY;
+}
 
-//! State for iterating over blocks of an in-memory TupleDataCollection
-//! Multiple iterators can share the same state, everything is const
-class InMemoryBlockIteratorState {
-public:
-	explicit InMemoryBlockIteratorState(const TupleDataCollection &key_data);
-
-public:
-	template <class T>
-	T &GetValueAtIndex(const idx_t &block_idx, const idx_t &tuple_idx) const {
-		D_ASSERT(GetIndex(block_idx, tuple_idx) < tuple_count);
-		return reinterpret_cast<T *const>(block_ptrs[block_idx])[tuple_idx];
+template <class BLOCK_ITERATOR_STATE>
+class BlockIteratorStateBase {
+protected:
+	friend BLOCK_ITERATOR_STATE;
+	explicit BlockIteratorStateBase(const idx_t tuple_count_p) : tuple_count(tuple_count_p) {
 	}
 
-	template <class T>
-	T &GetValueAtIndex(const idx_t &n) const {
-		const auto quotient = fast_mod.Div(n);
-		return GetValueAtIndex<T>(quotient, fast_mod.Mod(n, quotient));
+public:
+	idx_t GetDivisor() const {
+		const auto &state = static_cast<const BLOCK_ITERATOR_STATE &>(*this);
+		return state.GetDivisor();
 	}
 
-	void RandomAccess(idx_t &block_idx, idx_t &tuple_idx, const idx_t &index) const {
-		block_idx = fast_mod.Div(index);
-		tuple_idx = fast_mod.Mod(index, block_idx);
+	void RandomAccess(idx_t &block_or_chunk_idx, idx_t &tuple_idx, const idx_t &index) const {
+		const auto &state = static_cast<const BLOCK_ITERATOR_STATE &>(*this);
+		state.RandomAccessInternal(block_or_chunk_idx, tuple_idx, index);
 	}
 
-	void Add(idx_t &block_idx, idx_t &tuple_idx, const idx_t &value) const {
+	void Add(idx_t &block_or_chunk_idx, idx_t &tuple_idx, const idx_t &value) const {
 		tuple_idx += value;
-		if (tuple_idx >= fast_mod.GetDivisor()) {
-			const auto div = fast_mod.Div(tuple_idx);
-			tuple_idx -= div * fast_mod.GetDivisor();
-			block_idx += div;
+		if (tuple_idx >= GetDivisor()) {
+			RandomAccess(block_or_chunk_idx, tuple_idx, GetIndex(block_or_chunk_idx, tuple_idx));
 		}
 	}
 
-	void Subtract(idx_t &block_idx, idx_t &tuple_idx, const idx_t &value) const {
+	void Subtract(idx_t &block_or_chunk_idx, idx_t &tuple_idx, const idx_t &value) const {
 		tuple_idx -= value;
-		if (tuple_idx >= fast_mod.GetDivisor()) {
-			const auto div = fast_mod.Div(-tuple_idx);
-			tuple_idx += (div + 1) * fast_mod.GetDivisor();
-			block_idx -= div + 1;
+		if (tuple_idx >= GetDivisor()) {
+			RandomAccess(block_or_chunk_idx, tuple_idx, GetIndex(block_or_chunk_idx, tuple_idx));
 		}
 	}
 
-	void Increment(idx_t &block_idx, idx_t &tuple_idx) const {
-		const auto passed_boundary = ++tuple_idx == fast_mod.GetDivisor();
-		block_idx += passed_boundary;
-		tuple_idx *= !passed_boundary;
+	void Increment(idx_t &block_or_chunk_idx, idx_t &tuple_idx) const {
+		const auto crossed_boundary = ++tuple_idx == GetDivisor();
+		block_or_chunk_idx += crossed_boundary;
+		tuple_idx *= !crossed_boundary;
 	}
 
-	void Decrement(idx_t &block_idx, idx_t &tuple_idx) const {
+	void Decrement(idx_t &block_or_chunk_idx, idx_t &tuple_idx) const {
 		const auto crossed_boundary = tuple_idx-- == 0;
-		block_idx -= crossed_boundary;
-		tuple_idx += crossed_boundary * fast_mod.GetDivisor();
+		block_or_chunk_idx -= crossed_boundary;
+		tuple_idx += crossed_boundary * GetDivisor();
+	}
+
+	idx_t GetIndex(const idx_t &block_or_chunk_idx, const idx_t &tuple_idx) const {
+		return block_or_chunk_idx * GetDivisor() + tuple_idx;
+	}
+
+protected:
+	const idx_t tuple_count;
+};
+
+template <BlockIteratorStateType>
+class BlockIteratorState;
+
+//! State for iterating over blocks of an in-memory TupleDataCollection
+//! Multiple iterators can share the same state, everything is const
+template <>
+class BlockIteratorState<BlockIteratorStateType::IN_MEMORY>
+    : public BlockIteratorStateBase<BlockIteratorState<BlockIteratorStateType::IN_MEMORY>> {
+public:
+	explicit BlockIteratorState(const TupleDataCollection &key_data)
+	    : BlockIteratorStateBase(key_data.Count()), block_ptrs(ConvertBlockPointers(key_data.GetRowBlockPointers())),
+	      fast_mod(key_data.TuplesPerBlock()) {
+	}
+
+public:
+	idx_t GetDivisor() const {
+		return fast_mod.GetDivisor();
+	}
+
+	void RandomAccessInternal(idx_t &block_idx, idx_t &tuple_idx, const idx_t &index) const {
+		block_idx = fast_mod.Div(index);
+		tuple_idx = fast_mod.Mod(index, block_idx);
+	}
+
+	template <class T>
+	T &GetValueAtIndex(const idx_t &block_idx, const idx_t &tuple_idx) const {
+		D_ASSERT(GetIndex(block_idx, tuple_idx) < tuple_count);
+		return reinterpret_cast<T *const>(block_ptrs[block_idx])[tuple_idx];
 	}
 
-	idx_t GetIndex(const idx_t &block_idx, const idx_t &tuple_idx) const {
-		return block_idx * fast_mod.GetDivisor() + tuple_idx;
+	template <class T>
+	T &GetValueAtIndex(const idx_t &index) const {
+		idx_t block_idx;
+		idx_t tuple_idx;
+		RandomAccess(block_idx, tuple_idx, index);
+		return GetValueAtIndex<T>(block_idx, tuple_idx);
 	}
 
 	void SetKeepPinned(const bool &) {
@@ -92,72 +126,63 @@ public:
 	}
 
 private:
-	static unsafe_vector<data_ptr_t> ConvertBlockPointers(const vector<data_ptr_t> &block_ptrs);
+	static unsafe_vector<data_ptr_t> ConvertBlockPointers(const vector<data_ptr_t> &block_ptrs) {
+		unsafe_vector<data_ptr_t> converted_block_ptrs;
+		converted_block_ptrs.reserve(block_ptrs.size());
+		for (const auto &block_ptr : block_ptrs) {
+			converted_block_ptrs.emplace_back(block_ptr);
+		}
+		return converted_block_ptrs;
+	}
 
 private:
 	const unsafe_vector<data_ptr_t> block_ptrs;
 	const FastMod<idx_t> fast_mod;
-	const idx_t tuple_count;
 };
 
+using InMemoryBlockIteratorState = BlockIteratorState<BlockIteratorStateType::IN_MEMORY>;
+
 //! State for iterating over blocks of an external (larger-than-memory) TupleDataCollection
 //! This state cannot be shared by multiple iterators, it is stateful
-class ExternalBlockIteratorState {
+template <>
+class BlockIteratorState<BlockIteratorStateType::EXTERNAL>
+    : public BlockIteratorStateBase<BlockIteratorState<BlockIteratorStateType::EXTERNAL>> {
 public:
-	explicit ExternalBlockIteratorState(TupleDataCollection &key_data, optional_ptr<TupleDataCollection> payload_data);
-
-public:
-	template <class T>
-	T &GetValueAtIndex(const idx_t &chunk_idx, const idx_t &tuple_idx) {
-		if (chunk_idx != current_chunk_idx) {
-			InitializeChunk<T>(chunk_idx);
+	explicit BlockIteratorState(TupleDataCollection &key_data_p, optional_ptr<TupleDataCollection> payload_data_p)
+	    : BlockIteratorStateBase(key_data_p.Count()), current_chunk_idx(DConstants::INVALID_INDEX),
+	      key_data(key_data_p), key_ptrs(FlatVector::GetData<data_ptr_t>(key_scan_state.chunk_state.row_locations)),
+	      payload_data(payload_data_p), keep_pinned(false), pin_payload(false) {
+		key_data.InitializeScan(key_scan_state);
+		if (payload_data) {
+			payload_data->InitializeScan(payload_scan_state);
 		}
-		return *reinterpret_cast<T **const>(key_ptrs)[tuple_idx];
 	}
 
-	template <class T>
-	T &GetValueAtIndex(const idx_t &n) {
-		D_ASSERT(n < tuple_count);
-		return GetValueAtIndex<T>(n / STANDARD_VECTOR_SIZE, n % STANDARD_VECTOR_SIZE);
+public:
+	static constexpr idx_t GetDivisor() {
+		return STANDARD_VECTOR_SIZE;
 	}
 
-	static void RandomAccess(idx_t &chunk_idx, idx_t &tuple_idx, const idx_t &index) {
+	static void RandomAccessInternal(idx_t &chunk_idx, idx_t &tuple_idx, const idx_t &index) {
 		chunk_idx = index / STANDARD_VECTOR_SIZE;
 		tuple_idx = index % STANDARD_VECTOR_SIZE;
 	}
 
-	static void Add(idx_t &chunk_idx, idx_t &tuple_idx, const idx_t &value) {
-		tuple_idx += value;
-		if (tuple_idx >= STANDARD_VECTOR_SIZE) {
-			const auto div = tuple_idx / STANDARD_VECTOR_SIZE;
-			tuple_idx -= div * STANDARD_VECTOR_SIZE;
-			chunk_idx += div;
-		}
-	}
-
-	static void Subtract(idx_t &chunk_idx, idx_t &tuple_idx, const idx_t &value) {
-		tuple_idx -= value;
-		if (tuple_idx >= STANDARD_VECTOR_SIZE) {
-			const auto div = -tuple_idx / STANDARD_VECTOR_SIZE;
-			tuple_idx += (div + 1) * STANDARD_VECTOR_SIZE;
-			chunk_idx -= div + 1;
+	template <class T>
+	T &GetValueAtIndex(const idx_t &chunk_idx, const idx_t &tuple_idx) {
+		D_ASSERT(GetIndex(chunk_idx, tuple_idx) < tuple_count);
+		if (chunk_idx != current_chunk_idx) {
+			InitializeChunk<T>(chunk_idx);
 		}
+		return *reinterpret_cast<T **const>(key_ptrs)[tuple_idx];
 	}
 
-	static void Increment(idx_t &chunk_idx, idx_t &tuple_idx) {
-		const auto passed_boundary = ++tuple_idx == STANDARD_VECTOR_SIZE;
-		chunk_idx += passed_boundary;
-		tuple_idx *= !passed_boundary;
-	}
-
-	static void Decrement(idx_t &chunk_idx, idx_t &tuple_idx) {
-		const auto crossed_boundary = tuple_idx-- == 0;
-		chunk_idx -= crossed_boundary;
-		tuple_idx += crossed_boundary * static_cast<idx_t>(STANDARD_VECTOR_SIZE);
-	}
-
-	static idx_t GetIndex(const idx_t &chunk_idx, const idx_t &tuple_idx) {
-		return chunk_idx * STANDARD_VECTOR_SIZE + tuple_idx;
+	template <class T>
+	T &GetValueAtIndex(const idx_t &index) {
+		idx_t chunk_idx;
+		idx_t tuple_idx;
+		RandomAccess(chunk_idx, tuple_idx, index);
+		return GetValueAtIndex<T>(chunk_idx, tuple_idx);
 	}
 
 	void SetKeepPinned(const bool &enable) {
@@ -201,7 +226,6 @@ private:
 	}
 
 private:
-	const idx_t tuple_count;
 	idx_t current_chunk_idx;
 
 	TupleDataCollection &key_data;
@@ -216,13 +240,7 @@ private:
 	vector<BufferHandle> pins;
 };
 
-//! Utility so we can get the state using the type
-template <BlockIteratorStateType T>
-using BlockIteratorState = typename std::conditional<
-    T == BlockIteratorStateType::IN_MEMORY, InMemoryBlockIteratorState,
-    typename std::conditional<T == BlockIteratorStateType::EXTERNAL, ExternalBlockIteratorState,
-                              void // Compiler throws error if we get here
-                              >::type>::type;
+using ExternalBlockIteratorState = BlockIteratorState<BlockIteratorStateType::EXTERNAL>;
 
 //! Iterator for data spread out over multiple blocks
 template <class STATE, class T>
@@ -305,16 +323,16 @@ public:
 		return *this;
 	}
 	block_iterator_t operator+(const difference_type &n) const {
-		idx_t new_block_idx = block_or_chunk_idx;
+		idx_t new_block_or_chunk_idx = block_or_chunk_idx;
 		idx_t new_tuple_idx = tuple_idx;
-		state->Add(new_block_idx, new_tuple_idx, n);
-		return block_iterator_t(*state, new_block_idx, new_tuple_idx);
+		state->Add(new_block_or_chunk_idx, new_tuple_idx, n);
+		return block_iterator_t(*state, new_block_or_chunk_idx, new_tuple_idx);
 	}
 	block_iterator_t operator-(const difference_type &n) const {
-		idx_t new_block_idx = block_or_chunk_idx;
+		idx_t new_block_or_chunk_idx = block_or_chunk_idx;
 		idx_t new_tuple_idx = tuple_idx;
-		state->Subtract(new_block_idx, new_tuple_idx, n);
-		return block_iterator_t(*state, new_block_idx, new_tuple_idx);
+		state->Subtract(new_block_or_chunk_idx, new_tuple_idx, n);
+		return block_iterator_t(*state, new_block_or_chunk_idx, new_tuple_idx);
 	}
 
 	reference operator[](const difference_type &n) const {

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

@@ -62,6 +62,60 @@ public:
 		return nullptr;
 	}
 
+	//! LookupInLeaf returns true if the rowid is in the leaf:
+	//! 1) If the leaf is an inlined leaf, check if the rowid matches.
+	//! 2) If the leaf is a gate node, perform a search in the nested ART for the rowid.
+	static bool LookupInLeaf(ART &art, const Node &node, const ARTKey &rowid) {
+		reference<const Node> ref(node);
+		idx_t depth = 0;
+
+		while (ref.get().HasMetadata()) {
+			const auto type = ref.get().GetType();
+			switch (type) {
+			case NType::LEAF_INLINED: {
+				return ref.get().GetRowId() == rowid.GetRowId();
+			}
+			case NType::LEAF: {
+				throw InternalException("Invalid node type (LEAF) for ARTOperator::NestedLookup.");
+			}
+			case NType::NODE_7_LEAF:
+			case NType::NODE_15_LEAF:
+			case NType::NODE_256_LEAF: {
+				D_ASSERT(depth + 1 == Prefix::ROW_ID_SIZE);
+				const auto byte = rowid[Prefix::ROW_ID_COUNT];
+				return ref.get().HasByte(art, byte);
+			}
+			case NType::NODE_4:
+			case NType::NODE_16:
+			case NType::NODE_48:
+			case NType::NODE_256: {
+				D_ASSERT(depth < Prefix::ROW_ID_SIZE);
+				auto child = ref.get().GetChild(art, rowid[depth]);
+				if (child) {
+					// Continue in the child.
+					ref = *child;
+					depth++;
+					D_ASSERT(ref.get().HasMetadata());
+					continue;
+				}
+				return false;
+			}
+			case NType::PREFIX: {
+				Prefix prefix(art, ref.get());
+				for (idx_t i = 0; i < prefix.data[Prefix::Count(art)]; i++) {
+					if (prefix.data[i] != rowid[depth]) {
+						// The key and the prefix don't match.
+						return false;
+					}
+					depth++;
+				}
+				ref = *prefix.ptr;
+			}
+			}
+		}
+		return false;
+	}
+
 	//! Insert a key and its row ID into the node.
 	//! Starts at depth (in the key).
 	//! status indicates if the insert happens inside a gate or not.

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

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include "duckdb/execution/index/unbound_index.hpp"
 #include "duckdb/common/enums/index_constraint_type.hpp"
 #include "duckdb/common/types/constraint_conflict_info.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
@@ -60,6 +61,16 @@ public:
 	//! The index constraint type
 	IndexConstraintType index_constraint_type;
 
+	//! The vector of unbound expressions, which are later turned into bound expressions.
+	//! We need to store the unbound expressions, as we might not always have the context
+	//! available to bind directly.
+	//! The leaves of these unbound expressions are BoundColumnRefExpressions.
+	//! These BoundColumnRefExpressions contain a binding (ColumnBinding),
+	//! and that contains a table_index and a column_index.
+	//! The table_index is a dummy placeholder.
+	//! The column_index indexes the column_ids vector in the Index base class.
+	//! Those column_ids store the physical table indexes of the Index,
+	//! and we use them when binding the unbound expressions.
 	vector<unique_ptr<Expression>> unbound_expressions;
 
 public:
@@ -155,14 +166,22 @@ public:
 	virtual string GetConstraintViolationMessage(VerifyExistenceType verify_type, idx_t failed_index,
 	                                             DataChunk &input) = 0;
 
-	void ApplyBufferedAppends(const vector<LogicalType> &table_types, ColumnDataCollection &buffered_appends,
+	//! Replay index insert and delete operations buffered during WAL replay.
+	//! table_types has the physical types of the table in the order they appear, not logical (no generated columns).
+	//! mapped_column_ids contains the sorted order of Indexed physical column ID's (see unbound_index.hpp comments).
+	void ApplyBufferedReplays(const vector<LogicalType> &table_types, vector<BufferedIndexData> &buffered_replays,
 	                          const vector<StorageIndex> &mapped_column_ids);
 
 protected:
 	//! Lock used for any changes to the index
 	mutex lock;
 
-	//! Bound expressions used during expression execution
+	//! The vector of bound expressions to generate the Index keys based on a data chunk.
+	//! The leaves of the bound expressions are BoundReferenceExpressions.
+	//! These BoundReferenceExpressions contain offsets into the DataChunk to retrieve the columns
+	//! for the expression.
+	//!	With these offsets into the DataChunk, the expression executor can now evaluate the expression
+	//! on incoming data chunks to generate the keys.
 	vector<unique_ptr<Expression>> bound_expressions;
 
 private: