duckdb 1.3.3-dev4.0 → 1.3.3

package/src/duckdb/src/include/duckdb/common/types/column/column_data_allocator.hpp

@@ -14,7 +14,6 @@ namespace duckdb {
 
 struct ChunkMetaData;
 struct VectorMetaData;
-struct SwizzleMetaData;
 
 struct BlockMetaData {
 	//! The underlying block handle
@@ -76,8 +75,8 @@ public:
 	void Initialize(ColumnDataAllocator &other);
 	void InitializeChunkState(ChunkManagementState &state, ChunkMetaData &meta_data);
 	data_ptr_t GetDataPointer(ChunkManagementState &state, uint32_t block_id, uint32_t offset);
-	void UnswizzlePointers(ChunkManagementState &state, Vector &result, SwizzleMetaData &swizzle_segment,
-	                       const VectorMetaData &string_heap_segment, const idx_t &v_offset, const bool &copied);
+	void UnswizzlePointers(ChunkManagementState &state, Vector &result, idx_t v_offset, uint16_t count,
+	                       uint32_t block_id, uint32_t offset);
 
 	//! Prevents the block with the given id from being added to the eviction queue
 	void SetDestroyBufferUponUnpin(uint32_t block_id);

package/src/duckdb/src/include/duckdb/common/types/column/column_data_collection_segment.hpp

@@ -36,13 +36,11 @@ struct VectorDataIndex {
 };
 
 struct SwizzleMetaData {
-	SwizzleMetaData(VectorDataIndex child_index_p, data_ptr_t ptr_p, uint16_t offset_p, uint16_t count_p)
-	    : child_index(child_index_p), ptr(ptr_p), offset(offset_p), count(count_p) {
+	SwizzleMetaData(VectorDataIndex child_index_p, uint16_t offset_p, uint16_t count_p)
+	    : child_index(child_index_p), offset(offset_p), count(count_p) {
 	}
 	//! Index of block storing heap
 	VectorDataIndex child_index;
-	//! Last-known pointer
-	data_ptr_t ptr;
 	//! Offset into the string_t vector
 	uint16_t offset;
 	//! Number of strings starting at 'offset' that have strings stored in the block with index 'child_index'

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

@@ -9,8 +9,9 @@
 #pragma once
 
 #include "duckdb/common/common.hpp"
-#include "duckdb/common/vector.hpp"
 #include "duckdb/execution/index/art/art.hpp"
+#include "duckdb/common/types/selection_vector.hpp"
+#include "duckdb/common/vector.hpp"
 
 namespace duckdb {
 
@@ -18,226 +19,79 @@ class Index;
 class ConflictInfo;
 
 enum class ConflictManagerMode : uint8_t {
-	SCAN, // Gather conflicts without throwing a constraint exception.
-	THROW // Throw on the conflicts that were not found during the scan.
+	SCAN, // gather conflicts without throwing
+	THROW // throw on the conflicts that were not found during the scan
 };
 
 enum class LookupResultType : uint8_t { LOOKUP_MISS, LOOKUP_HIT, LOOKUP_NULL };
 
-//! The conflict manager tracks conflicts during constraint verification.
-//! It decides when/if to throw, and records conflicts to be used later in case
-//! of ON CONFLICT DO. The conflict manager operates on a per-chunk basis,
-//! i.e., we construct a new conflict manager per incoming chunk.
-//! On conflict manager can gather conflicts across multiple indexes, if
-//! they match the ON CONFLICT DO target.
 class ConflictManager {
 public:
-	static constexpr uint8_t FIRST = 0;
-	static constexpr uint8_t SECOND = 1;
-
-public:
-	ConflictManager(const VerifyExistenceType lookup_type, const idx_t chunk_size,
+	ConflictManager(VerifyExistenceType lookup_type, idx_t input_size,
 	                optional_ptr<ConflictInfo> conflict_info = nullptr);
 
 public:
-	//! Returns true, if we need to throw, otherwise, adds the hit and returns false.
-	bool AddHit(const idx_t index_in_chunk, const row_t row_id);
-	//! Returns true, if we need to throw, otherwise, adds the second hit and returns false.
-	bool AddSecondHit(const idx_t index_in_chunk, const row_t row_id);
-	//! Returns true, if we need to throw, otherwise, adds the NULL and returns false.
-	bool AddNull(const idx_t index_in_chunk);
-	//! Returns the index of the first (in)valid row, if any.
-	optional_idx GetFirstInvalidIndex(const idx_t count, const bool negate = false);
-
-	//! Finalizes a global conflict manager.
-	void FinalizeGlobal(DuckTransaction &transaction, DataTable &table);
-	//! Finalizes a local conflict manager.
-	void FinalizeLocal(DataTable &table, LocalStorage &storage);
-	//! Determines if we are finished registering conflicts.
+	// These methods return a boolean indicating whether we should throw or not
+	bool AddMiss(idx_t chunk_index);
+	bool AddHit(idx_t chunk_index, row_t row_id);
+	bool AddNull(idx_t chunk_index);
+	VerifyExistenceType LookupType() const;
+	// This should be called before using the conflicts selection vector
+	void Finalize();
+
+	Vector &RowIds();
+	const ConflictInfo &GetConflictInfo() const;
 	void FinishLookup();
-
-	//! Get the conflict information.
-	const ConflictInfo &GetConflictInfo() const {
-		return *conflict_info;
-	}
-	//! Sets the mode of the conflict manager.
-	void SetMode(const ConflictManagerMode mode_p) {
-		D_ASSERT(mode_p != ConflictManagerMode::SCAN || conflict_info != nullptr);
-		mode = mode_p;
-	}
-
-	//! Adds an index and its respective delete_index.
-	void AddIndex(BoundIndex &index, optional_ptr<BoundIndex> delete_index) {
-		matching_indexes.push_back(index);
-		matching_delete_indexes.push_back(delete_index);
-		index_names.insert(index.name);
-	}
+	void SetMode(ConflictManagerMode mode);
+
+	//! Returns a reference to all conflicts in this conflict manager.
+	const ManagedSelection &Conflicts() const;
+	//! Returns the number of conflicts in this conflict manager.
+	idx_t ConflictCount() const;
+	//! Adds an index and its respective delete_index to the conflict manager's matches.
+	void AddIndex(BoundIndex &index, optional_ptr<BoundIndex> delete_index);
 	//! Returns true, if the index is in this conflict manager.
-	bool IndexMatches(BoundIndex &index) {
-		return index_names.find(index.name) != index_names.end();
-	}
-	//! Returns a reference to the matching indexes.
-	const vector<reference<BoundIndex>> &MatchingIndexes() const {
-		return matching_indexes;
-	}
-	//! Returns a reference to the matching delete indexes.
-	const vector<optional_ptr<BoundIndex>> &MatchingDeleteIndexes() const {
-		return matching_delete_indexes;
-	}
+	bool MatchedIndex(BoundIndex &index);
+	//! Returns a reference to the matched indexes.
+	const vector<reference<BoundIndex>> &MatchedIndexes() const;
+	//! Returns a reference to the matched delete indexes.
+	const vector<optional_ptr<BoundIndex>> &MatchedDeleteIndexes() const;
 
-	//! Returns the existence verification type.
-	VerifyExistenceType GetVerifyExistenceType() const {
-		return verify_existence_type;
-	}
-	//! Returns true, if there are any conflicts, else false.
-	bool HasConflicts() const {
-		return conflict_data[FIRST].sel != nullptr;
-	}
-	//! Returns the number of conflicts.
-	idx_t ConflictCount() const {
-		if (!HasConflicts()) {
-			return 0;
-		}
-		return conflict_data[FIRST].count;
-	}
-	//! Returns a reference to the row IDs.
-	//! Must be called after Finalize[Global|Local].
-	Vector &GetRowIds() {
-		D_ASSERT(!conflict_data[SECOND].sel);
-		return *GetConflictData(FIRST).row_ids;
-	}
-	//! Returns a reference to the inverted selection vector.
-	//! Must be called after Finalize[Global|Local].
-	SelectionVector &GetInvertedSel() const {
-		D_ASSERT(!conflict_data[SECOND].sel);
-		return *conflict_data[FIRST].inverted_sel;
-	}
-	//! Returns the first index in a chunk with a conflict.
-	idx_t GetFirstIndex() const {
-		return GetInvertedSel().get_index(0);
-	}
-	//! Returns the validity array of the first conflict data.
-	ValidityArray &GetFirstValidity() {
-		D_ASSERT(HasConflicts());
-		return conflict_data[FIRST].validity;
-	}
+private:
+	bool IsConflict(LookupResultType type);
+	const unordered_set<idx_t> &InternalConflictSet() const;
+	Vector &InternalRowIds();
+	Vector &InternalIntermediate();
+	ManagedSelection &InternalSelection();
+	bool SingleIndexTarget() const;
+	bool ShouldThrow(idx_t chunk_index) const;
+	bool ShouldIgnoreNulls() const;
+	void AddConflictInternal(idx_t chunk_index, row_t row_id);
+	void AddToConflictSet(idx_t chunk_index);
 
 private:
-	//! The type of constraint verification for which we're using the conflict manager.
-	VerifyExistenceType verify_existence_type;
-	//! The count of the data chunk for which we've created the conflict manager.
-	idx_t chunk_size;
-	//! Optional information to match indexes to the conflict target.
+	VerifyExistenceType lookup_type;
+	idx_t input_size;
 	optional_ptr<ConflictInfo> conflict_info;
-	//! The mode of the conflict manager.
+	bool finalized = false;
+	ManagedSelection conflicts;
+	unique_ptr<Vector> row_ids;
+	// Used to check if a given conflict is part of the conflict target or not
+	unique_ptr<unordered_set<idx_t>> conflict_set;
+	// Contains 'input_size' booleans, indicating if a given index in the input chunk has a conflict
+	unique_ptr<Vector> intermediate_vector;
+	// Mapping from chunk_index to row_id
+	vector<row_t> row_id_map;
+	// Whether we have already found the one conflict target we're interested in
+	bool single_index_finished = false;
 	ConflictManagerMode mode;
 
 	//! Indexes matching the conflict target.
-	vector<reference<BoundIndex>> matching_indexes;
+	vector<reference<BoundIndex>> matched_indexes;
 	//! Delete indexes matching the conflict target.
-	vector<optional_ptr<BoundIndex>> matching_delete_indexes;
-	//! All matching indexes by their name (unique identifier).
-	case_insensitive_set_t index_names;
-
-	//! Registers all conflicting rows in a data chunk.
-	unordered_set<idx_t> conflict_rows;
-	//! True, if we can skip recording any further conflicts.
-	bool finished = false;
-
-	//! ConflictData is a helper struct tracking conflicts for each index in a chunk,
-	//! as well as the total conflict count, and the row ID matching each conflict.
-	struct ConflictData {
-		//! Conflict count.
-		idx_t count = 0;
-		//! Links the conflicting rows to their row IDs (index_in_chunk -> count).
-		unique_ptr<SelectionVector> sel;
-		//! Inverted selection vector to slice the input chunk (count -> index_in_chunk).
-		unique_ptr<SelectionVector> inverted_sel;
-		//! Row IDs.
-		unique_ptr<Vector> row_ids;
-		//! Optional row ID data.
-		row_t *row_ids_data;
-		//! Keeps track of the indexes in the chunk for which we've seen a conflict.
-		//! True (valid) indicates a conflict.
-		ValidityArray validity;
-
-		//! Inserts a conflict into the two selection vectors, the row IDs, and the validity.
-		void Insert(const idx_t index_in_chunk, const row_t row_id) {
-			D_ASSERT(!validity.RowIsValid(index_in_chunk));
-			sel->set_index(index_in_chunk, count);
-			inverted_sel->set_index(count, index_in_chunk);
-			validity.SetValid(index_in_chunk);
-			row_ids_data[count] = row_id;
-			count++;
-		}
-
-		//! Returns the row ID matching the index in the chunk.
-		row_t GetRowId(const idx_t index_in_chunk) {
-			D_ASSERT(validity.RowIsValid(index_in_chunk));
-			auto idx = sel->get_index(index_in_chunk);
-			return row_ids_data[idx];
-		}
-
-		//! Resets the conflict data.
-		void Reset() {
-			count = 0;
-			sel = nullptr;
-			inverted_sel = nullptr;
-			row_ids_data = nullptr;
-			row_ids = nullptr;
-		}
-	};
-
-	//! With the introduction of delete indexes, it is now possible to have up to two row IDs
-	//! in a UNIQUE/PRIMARY KEY leaf. Only one of the row IDs is visible to the transaction in
-	//! which we're using the conflict manager. Thus, we need to register both row IDs when
-	//! scanning, and later Finalize the conflict data to only contain the visible row ID.
-	array<ConflictData, 2> conflict_data;
-
-private:
-	//! Returns true, if we register a conflict for the lookup type.
-	bool IsConflict(LookupResultType type);
-	//! Adds a hit to the conflicts.
-	bool AddHit(const idx_t index_in_chunk, const std::function<void()> &callback);
-	//! Determine visible row ID for each index with two possible row IDs.
-	void Finalize(const std::function<bool(const row_t row_id)> &callback);
-	//! Returns true, if the conflict manager should throw an exception, else false.
-	bool ShouldThrow(const idx_t index_in_chunk) const;
-	//! Returns true, if we ignore NULLs, else false.
-	bool IgnoreNulls() const;
-
-	//! Returns a reference to the conflict data (FIRST or SECOND),
-	//! and initializes it, if uninitialized.
-	ConflictData &GetConflictData(const idx_t i) {
-		if (conflict_data[i].sel) {
-			return conflict_data[i];
-		}
-		conflict_data[i].sel = make_uniq<SelectionVector>(chunk_size);
-		conflict_data[i].inverted_sel = make_uniq<SelectionVector>(chunk_size);
-		conflict_data[i].validity.Initialize(chunk_size, false);
-		conflict_data[i].row_ids = make_uniq<Vector>(LogicalType::ROW_TYPE, chunk_size);
-		conflict_data[i].row_ids_data = FlatVector::GetData<row_t>(*conflict_data[i].row_ids);
-		return conflict_data[i];
-	}
-
-	//! Adds a row ID to the primary conflict data.
-	void AddRowId(const idx_t index_in_chunk, const row_t row_id) {
-		// Only ON CONFLICT DO NOTHING can have multiple conflict targets,
-		// which can cause multiple row IDs per index_in_chunk.
-		// We let them overwrite each other, as we don't need the row IDs later.
-		auto elem = conflict_rows.find(index_in_chunk);
-		if (elem == conflict_rows.end()) {
-			// We have not yet seen this conflict: insert.
-			conflict_rows.insert(index_in_chunk);
-			GetConflictData(FIRST).Insert(index_in_chunk, row_id);
-		}
-	}
-
-	//! Adds a row ID to the secondary conflict data.
-	void AddSecondRowId(const idx_t index_in_chunk, const row_t row_id) {
-		D_ASSERT(conflict_rows.find(index_in_chunk) != conflict_rows.end());
-		GetConflictData(SECOND).Insert(index_in_chunk, row_id);
-	}
+	vector<optional_ptr<BoundIndex>> matched_delete_indexes;
+	//! All matched indexes by their name, which is their unique identifier.
+	case_insensitive_set_t matched_index_names;
 };
 
 } // namespace duckdb

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

@@ -1,28 +1,26 @@
 #pragma once
 
 #include "duckdb/common/common.hpp"
+#include "duckdb/common/types/selection_vector.hpp"
+#include "duckdb/common/types/vector.hpp"
 #include "duckdb/common/unordered_set.hpp"
 
 namespace duckdb {
 
 class Index;
 
-//! ConflictInfo contains information to match indexes to ON CONFLICT DO targets.
 class ConflictInfo {
 public:
 	explicit ConflictInfo(const unordered_set<column_t> &column_ids, bool only_check_unique = true)
 	    : column_ids(column_ids), only_check_unique(only_check_unique) {
 	}
-
 	const unordered_set<column_t> &column_ids;
-	bool only_check_unique = true;
 
 public:
 	bool ConflictTargetMatches(Index &index) const;
-	//! True, if the conflict info references the column ids of a single index, else false.
-	bool SingleIndexTarget() const {
-		return !column_ids.empty();
-	}
+
+public:
+	bool only_check_unique = true;
 };
 
 } // namespace duckdb

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

@@ -139,7 +139,7 @@ public:
 	DUCKDB_API void Slice(idx_t offset, idx_t count);
 
 	//! Resets the DataChunk to its state right after the DataChunk::Initialize
-	//! function was called. This sets the count to 0, the capacity to initial_capacity and resets each member
+	//! function was called. This sets the count to 0, and resets each member
 	//! Vector to point back to the data owned by this DataChunk.
 	DUCKDB_API void Reset();
 
@@ -169,8 +169,6 @@ private:
 	idx_t count;
 	//! The amount of tuples that can be stored in the data chunk
 	idx_t capacity;
-	//! The initial capacity of this chunk set during ::Initialize, used when resetting
-	idx_t initial_capacity;
 	//! Vector caches, used to store data when ::Initialize is called
 	vector<VectorCache> vector_caches;
 };

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

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include "duckdb/common/common.hpp"
 #include "duckdb/common/types.hpp"
 #include "duckdb/common/winapi.hpp"
 #include "duckdb/common/types/string_type.hpp"
@@ -84,17 +85,12 @@ struct date_t { // NOLINT
 
 enum class DateCastResult : uint8_t { SUCCESS, ERROR_INCORRECT_FORMAT, ERROR_RANGE };
 
-struct DateSpecial {
-	const char *str;  // The full string
-	const idx_t abbr; // The abbreviation length
-};
-
 //! The Date class is a static class that holds helper functions for the Date type.
 class Date {
 public:
-	static const DateSpecial PINF;  // NOLINT
-	static const DateSpecial NINF;  // NOLINT
-	static const DateSpecial EPOCH; // NOLINT
+	static const char *PINF;  // NOLINT
+	static const char *NINF;  // NOLINT
+	static const char *EPOCH; // NOLINT
 
 	static const string_t MONTH_NAMES[12];
 	static const string_t MONTH_NAMES_ABBREVIATED[12];
@@ -130,7 +126,7 @@ public:
 	DUCKDB_API static string ToString(date_t date);
 	//! Try to convert the string as a give "special" date (e.g, PINF, ...)
 	//! Returns true if it was successful and updates the scan pos.
-	DUCKDB_API static bool TryConvertDateSpecial(const char *buf, idx_t len, idx_t &pos, const DateSpecial &special);
+	DUCKDB_API static bool TryConvertDateSpecial(const char *buf, idx_t len, idx_t &pos, const char *special);
 	//! Try to convert text in a buffer to a date; returns true if parsing was successful
 	//! If the date was a "special" value, the special flag will be set.
 	DUCKDB_API static DateCastResult TryConvertDate(const char *buf, idx_t len, idx_t &pos, date_t &result,

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

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include "duckdb/common/common.hpp"
 #include "duckdb/common/numeric_utils.hpp"
 
 #include <functional>
@@ -19,7 +20,7 @@ struct dtime_t { // NOLINT
 	int64_t micros;
 
 	dtime_t() = default;
-	explicit inline constexpr dtime_t(int64_t micros_p) : micros(micros_p) {
+	explicit inline dtime_t(int64_t micros_p) : micros(micros_p) {
 	}
 	inline dtime_t &operator=(int64_t micros_p) {
 		micros = micros_p;
@@ -94,16 +95,6 @@ struct dtime_t { // NOLINT
 	} // NOLINT
 };
 
-//! Type used to represent TIME_NS. dtime_ns_t holds the nanoseconds since midnight.
-struct dtime_ns_t : public dtime_t { // NOLINT
-	dtime_ns_t() = default;
-	explicit inline constexpr dtime_ns_t(const int64_t nanos) : dtime_t(nanos) {
-	}
-	inline dtime_t time() const { // NOLINT
-		return dtime_t(micros / 1000);
-	}
-};
-
 struct dtime_tz_t { // NOLINT
 	static constexpr const int TIME_BITS = 40;
 	static constexpr const int OFFSET_BITS = 24;

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

@@ -17,22 +17,10 @@ namespace duckdb {
 struct string_t;
 struct interval_t; // NOLINT
 
-//! Combine two hashes by XORing them
-inline hash_t CombineHash(hash_t left, hash_t right) {
-	return left ^ right;
-}
+// efficient hash function that maximizes the avalanche effect and minimizes
+// bias
+// see: https://nullprogram.com/blog/2018/07/31/
 
-#ifdef DUCKDB_HASH_ZERO
-template <class T>
-hash_t Hash(T value) {
-	return 0;
-}
-
-DUCKDB_API hash_t Hash(const char *val, size_t size);
-DUCKDB_API hash_t Hash(uint8_t *val, size_t size);
-#else
-//! Efficient hash function that maximizes the avalanche effect and minimizes bias
-//! See: https://nullprogram.com/blog/2018/07/31/
 inline hash_t MurmurHash64(uint64_t x) {
 	x ^= x >> 32;
 	x *= 0xd6e8feb86659fd93U;
@@ -51,14 +39,15 @@ hash_t Hash(T value) {
 	return MurmurHash32(static_cast<uint32_t>(value));
 }
 
-template <>
-DUCKDB_API inline hash_t Hash(uint64_t val) {
-	return MurmurHash64(val);
+//! Combine two hashes by XORing them
+inline hash_t CombineHash(hash_t left, hash_t right) {
+	return left ^ right;
 }
+
 template <>
-DUCKDB_API inline hash_t Hash(int64_t val) {
-	return MurmurHash64(static_cast<uint64_t>(val));
-}
+DUCKDB_API hash_t Hash(uint64_t val);
+template <>
+DUCKDB_API hash_t Hash(int64_t val);
 template <>
 DUCKDB_API hash_t Hash(hugeint_t val);
 template <>
@@ -79,6 +68,5 @@ template <>
 DUCKDB_API hash_t Hash(dtime_tz_t val);
 DUCKDB_API hash_t Hash(const char *val, size_t size);
 DUCKDB_API hash_t Hash(uint8_t *val, size_t size);
-#endif
 
 } // namespace duckdb

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

@@ -66,7 +66,7 @@ public:
 	inline static hugeint_t Multiply(hugeint_t lhs, hugeint_t rhs) {
 		hugeint_t result;
 		if (!TryMultiply(lhs, rhs, result)) {
-			throw OutOfRangeException("Overflow in HUGEINT multiplication: %s * %s", lhs.ToString(), rhs.ToString());
+			throw OutOfRangeException("Overflow in HUGEINT multiplication: %s + %s", lhs.ToString(), rhs.ToString());
 		}
 		return result;
 	}
@@ -77,12 +77,12 @@ public:
 	inline static hugeint_t Divide(hugeint_t lhs, hugeint_t rhs) {
 		// No division by zero
 		if (rhs == 0) {
-			throw OutOfRangeException("Division of HUGEINT by zero: %s / %s", lhs.ToString(), rhs.ToString());
+			throw OutOfRangeException("Division of HUGEINT by zero!");
 		}
 
 		// division only has one reason to overflow: MINIMUM / -1
 		if (lhs == NumericLimits<hugeint_t>::Minimum() && rhs == -1) {
-			throw OutOfRangeException("Overflow in HUGEINT division: %s / %s", lhs.ToString(), rhs.ToString());
+			throw OutOfRangeException("Overflow in HUGEINT division: %s + %s", lhs.ToString(), rhs.ToString());
 		}
 		return Divide<false>(lhs, rhs);
 	}
@@ -91,12 +91,12 @@ public:
 	inline static hugeint_t Modulo(hugeint_t lhs, hugeint_t rhs) {
 		// No division by zero
 		if (rhs == 0) {
-			throw OutOfRangeException("Modulo of HUGEINT by zero: %s %% %s", lhs.ToString(), rhs.ToString());
+			throw OutOfRangeException("Modulo of HUGEINT by zero: %s + %s", lhs.ToString(), rhs.ToString());
 		}
 
 		// division only has one reason to overflow: MINIMUM / -1
 		if (lhs == NumericLimits<hugeint_t>::Minimum() && rhs == -1) {
-			throw OutOfRangeException("Overflow in HUGEINT modulo: %s %% %s", lhs.ToString(), rhs.ToString());
+			throw OutOfRangeException("Overflow in HUGEINT modulo: %s + %s", lhs.ToString(), rhs.ToString());
 		}
 		return Modulo<false>(lhs, rhs);
 	}
@@ -116,7 +116,7 @@ public:
 	template <bool CHECK_OVERFLOW = true>
 	inline static hugeint_t Subtract(hugeint_t lhs, hugeint_t rhs) {
 		if (!TrySubtractInPlace(lhs, rhs)) {
-			throw OutOfRangeException("Underflow in HUGEINT subtraction: %s - %s", lhs.ToString(), rhs.ToString());
+			throw OutOfRangeException("Underflow in HUGEINT addition: %s - %s", lhs.ToString(), rhs.ToString());
 		}
 		return lhs;
 	}

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

@@ -172,7 +172,7 @@ protected:
 	                       const idx_t append_count) const;
 	template <bool fixed>
 	static void BuildPartitionSel(PartitionedTupleDataAppendState &state, const SelectionVector &append_sel,
-	                              const idx_t append_count, const idx_t max_partition_idx);
+	                              const idx_t append_count);
 	//! Builds out the buffer space in the partitions
 	void BuildBufferSpace(PartitionedTupleDataAppendState &state);
 	template <bool fixed>

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

@@ -113,7 +113,8 @@ public:
 #ifdef DEBUG
 		for (auto &block : blocks) {
 			D_ASSERT(block->block->GetMemoryUsage() ==
-			         BufferManager::GetAllocSize(block->capacity * entry_size + Storage::DEFAULT_BLOCK_HEADER_SIZE));
+			         BufferManager::GetAllocSize(block->capacity * entry_size +
+			                                     buffer_manager.GetTemporaryBlockHeaderSize()));
 		}
 #endif
 	}

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

@@ -76,16 +76,12 @@ public:
 	//! Builds out the chunks for next append, given the metadata in the append state
 	void Build(TupleDataSegment &segment, TupleDataPinState &pin_state, TupleDataChunkState &chunk_state,
 	           const idx_t append_offset, const idx_t append_count);
-	bool BuildFastPath(TupleDataSegment &segment, TupleDataPinState &pin_state, TupleDataChunkState &chunk_state,
-	                   const idx_t append_offset, const idx_t append_count);
 	//! Initializes a chunk, making its pointers valid
 	void InitializeChunkState(TupleDataSegment &segment, TupleDataPinState &pin_state, TupleDataChunkState &chunk_state,
 	                          idx_t chunk_idx, bool init_heap);
 	static void RecomputeHeapPointers(Vector &old_heap_ptrs, const SelectionVector &old_heap_sel,
 	                                  const data_ptr_t row_locations[], Vector &new_heap_ptrs, const idx_t offset,
 	                                  const idx_t count, const TupleDataLayout &layout, const idx_t base_col_offset);
-	static void FindHeapPointers(TupleDataChunkState &chunk_state, SelectionVector &not_found, idx_t &not_found_count,
-	                             const TupleDataLayout &layout, const idx_t base_col_offset);
 	//! Releases or stores any handles in the management state that are no longer required
 	void ReleaseOrStoreHandles(TupleDataPinState &state, TupleDataSegment &segment, TupleDataChunk &chunk,
 	                           bool release_heap);
@@ -93,9 +89,6 @@ public:
 	void ReleaseOrStoreHandles(TupleDataPinState &state, TupleDataSegment &segment);
 	//! Sets 'can_destroy' to true for all blocks so they aren't added to the eviction queue
 	void SetDestroyBufferUponUnpin();
-	//! Destroy the blocks between the given indices
-	void DestroyRowBlocks(idx_t row_block_begin, idx_t row_block_end);
-	void DestroyHeapBlocks(idx_t heap_block_begin, idx_t heap_block_end);
 
 private:
 	//! Builds out a single part (grabs the lock)