duckdb 0.3.2-dev275.0 → 0.3.2-dev277.0

package/src/duckdb.cpp

@@ -29168,20 +29168,9 @@ private:
 } // namespace duckdb
 
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/sort/sort.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-//===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/common/sort/sorted_block.hpp
+// duckdb/common/fast_mem.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -29189,701 +29178,17 @@ private:
 
 
 
-namespace duckdb {
-
-class BufferManager;
-struct RowDataBlock;
-struct SortLayout;
-struct GlobalSortState;
-
-//! Object that holds sorted rows, and an accompanying heap if there are blobs
-struct SortedData {
-public:
-	SortedData(const RowLayout &layout, BufferManager &buffer_manager, GlobalSortState &state);
-	//! Number of rows that this object holds
-	idx_t Count();
-	//! Pin the current block so it can be read
-	void Pin();
-	//! Pointer to the row that is currently being read from
-	data_ptr_t DataPtr() const;
-	//! Pointer to the heap row that corresponds to the current row
-	data_ptr_t HeapPtr() const;
-	//! Advance one row
-	void Advance(const bool &adv);
-	//! Initialize new block to write to
-	void CreateBlock();
-	//! Reset read indices to the given indices
-	void ResetIndices(idx_t block_idx_to, idx_t entry_idx_to);
-	//! Create a slice that holds the rows between the start and end indices
-	unique_ptr<SortedData> CreateSlice(idx_t start_block_index, idx_t start_entry_index, idx_t end_block_index,
-	                                   idx_t end_entry_index);
-	//! Unswizzles all
-	void Unswizzle();
-
-public:
-	//! Layout of this data
-	const RowLayout layout;
-	//! Data and heap blocks
-	vector<RowDataBlock> data_blocks;
-	vector<RowDataBlock> heap_blocks;
-	//! Buffer handles to the data being currently read
-	unique_ptr<BufferHandle> data_handle;
-	unique_ptr<BufferHandle> heap_handle;
-	//! Read indices
-	idx_t block_idx;
-	idx_t entry_idx;
-	//! Whether the pointers in this sorted data are swizzled
-	bool swizzled;
-
-private:
-	//! Pin fixed-size row data
-	void PinData();
-	//! Pin the accompanying heap data (if any)
-	void PinHeap();
-
-private:
-	//! The buffer manager
-	BufferManager &buffer_manager;
-	//! The global state
-	GlobalSortState &state;
-	//! Pointers into the buffers being currently read
-	data_ptr_t data_ptr;
-	data_ptr_t heap_ptr;
-};
-
-//! Block that holds sorted rows: radix, blob and payload data
-struct SortedBlock {
-public:
-	SortedBlock(BufferManager &buffer_manager, GlobalSortState &gstate);
-	//! Number of rows that this object holds
-	idx_t Count() const;
-	//! The remaining number of rows to be read from this object
-	idx_t Remaining() const;
-	//! Initialize this block to write data to
-	void InitializeWrite();
-	//! Init new block to write to
-	void CreateBlock();
-	//! Pins radix block with given index
-	void PinRadix(idx_t pin_block_idx);
-	//! Fill this sorted block by appending the blocks held by a vector of sorted blocks
-	void AppendSortedBlocks(vector<unique_ptr<SortedBlock>> &sorted_blocks);
-	//! Locate the block and entry index of a row in this block,
-	//! given an index between 0 and the total number of rows in this block
-	void GlobalToLocalIndex(const idx_t &global_idx, idx_t &local_block_index, idx_t &local_entry_index);
-	//! Create a slice that holds the rows between the start and end indices
-	unique_ptr<SortedBlock> CreateSlice(const idx_t start, const idx_t end);
-
-	//! Size (in bytes) of the heap of this block
-	idx_t HeapSize() const;
-	//! Total size (in bytes) of this block
-	idx_t SizeInBytes() const;
-
-public:
-	//! Radix/memcmp sortable data
-	vector<RowDataBlock> radix_sorting_data;
-	unique_ptr<BufferHandle> radix_handle;
-	idx_t block_idx;
-	idx_t entry_idx;
-	//! Variable sized sorting data
-	unique_ptr<SortedData> blob_sorting_data;
-	//! Payload data
-	unique_ptr<SortedData> payload_data;
-
-private:
-	//! Buffer manager, and sorting layout constants
-	BufferManager &buffer_manager;
-	GlobalSortState &state;
-	const SortLayout &sort_layout;
-	const RowLayout &payload_layout;
-};
-
-struct SortedDataScanner {
-public:
-	SortedDataScanner(SortedData &sorted_data, GlobalSortState &global_sort_state);
-
-	//! Scans the next data chunk from the sorted data
-	void Scan(DataChunk &chunk);
-
-private:
-	//! The sorted data being scanned
-	SortedData &sorted_data;
-	//! The total count of sorted_data
-	const idx_t total_count;
-	//! The global sort state
-	GlobalSortState &global_sort_state;
-	//! Addresses used to gather from the sorted data
-	Vector addresses = Vector(LogicalType::POINTER);
-	//! The number of rows scanned so far
-	idx_t total_scanned;
-};
-
-} // namespace duckdb
 
 
+template <size_t SIZE>
+static inline void MemcpyFixed(void *dest, const void *src) {
+	memcpy(dest, src, SIZE);
+}
 
-
-namespace duckdb {
-
-class RowLayout;
-struct LocalSortState;
-
-struct SortConstants {
-	static constexpr idx_t VALUES_PER_RADIX = 256;
-	static constexpr idx_t MSD_RADIX_LOCATIONS = VALUES_PER_RADIX + 1;
-	static constexpr idx_t INSERTION_SORT_THRESHOLD = 24;
-	static constexpr idx_t MSD_RADIX_SORT_SIZE_THRESHOLD = 4;
-};
-
-struct SortLayout {
-public:
-	explicit SortLayout(const vector<BoundOrderByNode> &orders);
-
-public:
-	idx_t column_count;
-	vector<OrderType> order_types;
-	vector<OrderByNullType> order_by_null_types;
-	vector<LogicalType> logical_types;
-
-	bool all_constant;
-	vector<bool> constant_size;
-	vector<idx_t> column_sizes;
-	vector<idx_t> prefix_lengths;
-	vector<BaseStatistics *> stats;
-	vector<bool> has_null;
-
-	idx_t comparison_size;
-	idx_t entry_size;
-
-	RowLayout blob_layout;
-	unordered_map<idx_t, idx_t> sorting_to_blob_col;
-};
-
-struct GlobalSortState {
-public:
-	GlobalSortState(BufferManager &buffer_manager, const vector<BoundOrderByNode> &orders, RowLayout &payload_layout);
-
-	//! Add local state sorted data to this global state
-	void AddLocalState(LocalSortState &local_sort_state);
-	//! Prepares the GlobalSortState for the merge sort phase (after completing radix sort phase)
-	void PrepareMergePhase();
-	//! Initializes the global sort state for another round of merging
-	void InitializeMergeRound();
-	//! Completes the cascaded merge sort round
-	void CompleteMergeRound();
-
-public:
-	//! The lock for updating the order global state
-	mutex lock;
-	//! The buffer manager
-	BufferManager &buffer_manager;
-
-	//! Sorting and payload layouts
-	const SortLayout sort_layout;
-	const RowLayout payload_layout;
-
-	//! Sorted data
-	vector<unique_ptr<SortedBlock>> sorted_blocks;
-	vector<vector<unique_ptr<SortedBlock>>> sorted_blocks_temp;
-	unique_ptr<SortedBlock> odd_one_out;
-
-	//! Pinned heap data (if sorting in memory)
-	vector<RowDataBlock> heap_blocks;
-	vector<unique_ptr<BufferHandle>> pinned_blocks;
-
-	//! Capacity (number of rows) used to initialize blocks
-	idx_t block_capacity;
-	//! Whether we are doing an external sort
-	bool external;
-
-	//! Progress in merge path stage
-	idx_t pair_idx;
-	idx_t num_pairs;
-	idx_t l_start;
-	idx_t r_start;
-};
-
-struct LocalSortState {
-public:
-	LocalSortState();
-
-	//! Initialize the layouts and RowDataCollections
-	void Initialize(GlobalSortState &global_sort_state, BufferManager &buffer_manager_p);
-	//! Sink one DataChunk into the local sort state
-	void SinkChunk(DataChunk &sort, DataChunk &payload);
-	//! Size of accumulated data in bytes
-	idx_t SizeInBytes() const;
-	//! Sort the data accumulated so far
-	void Sort(GlobalSortState &global_sort_state, bool reorder_heap);
-
-private:
-	//! Concatenate the blocks held by a RowDataCollection into a single block
-	RowDataBlock ConcatenateBlocks(RowDataCollection &row_data);
-	//! Sorts the data in the newly created SortedBlock
-	void SortInMemory();
-	//! Re-order the local state after sorting
-	void ReOrder(GlobalSortState &gstate, bool reorder_heap);
-	//! Re-order a SortedData object after sorting
-	void ReOrder(SortedData &sd, data_ptr_t sorting_ptr, RowDataCollection &heap, GlobalSortState &gstate,
-	             bool reorder_heap);
-
-public:
-	//! Whether this local state has been initialized
-	bool initialized;
-	//! The buffer manager
-	BufferManager *buffer_manager;
-	//! The sorting and payload layouts
-	const SortLayout *sort_layout;
-	const RowLayout *payload_layout;
-	//! Radix/memcmp sortable data
-	unique_ptr<RowDataCollection> radix_sorting_data;
-	//! Variable sized sorting data and accompanying heap
-	unique_ptr<RowDataCollection> blob_sorting_data;
-	unique_ptr<RowDataCollection> blob_sorting_heap;
-	//! Payload data and accompanying heap
-	unique_ptr<RowDataCollection> payload_data;
-	unique_ptr<RowDataCollection> payload_heap;
-	//! Sorted data
-	vector<unique_ptr<SortedBlock>> sorted_blocks;
-
-private:
-	//! Selection vector and addresses for scattering the data to rows
-	const SelectionVector &sel_ptr = FlatVector::INCREMENTAL_SELECTION_VECTOR;
-	Vector addresses = Vector(LogicalType::POINTER);
-};
-
-struct MergeSorter {
-public:
-	MergeSorter(GlobalSortState &state, BufferManager &buffer_manager);
-
-	//! Finds and merges partitions until the current cascaded merge round is finished
-	void PerformInMergeRound();
-
-private:
-	//! Computes the left and right block that will be merged next (Merge Path partition)
-	void GetNextPartition();
-	//! Finds the boundary of the next partition using binary search
-	void GetIntersection(SortedBlock &l, SortedBlock &r, const idx_t diagonal, idx_t &l_idx, idx_t &r_idx);
-	//! Compare values within SortedBlocks using a global index
-	int CompareUsingGlobalIndex(SortedBlock &l, SortedBlock &r, const idx_t l_idx, const idx_t r_idx);
-
-	//! Finds the next partition and merges it
-	void MergePartition();
-
-	//! Computes how the next 'count' tuples should be merged by setting the 'left_smaller' array
-	void ComputeMerge(const idx_t &count, bool left_smaller[]);
-
-	//! Merges the radix sorting blocks according to the 'left_smaller' array
-	void MergeRadix(const idx_t &count, const bool left_smaller[]);
-	//! Merges SortedData according to the 'left_smaller' array
-	void MergeData(SortedData &result_data, SortedData &l_data, SortedData &r_data, const idx_t &count,
-	               const bool left_smaller[], idx_t next_entry_sizes[]);
-	//! Merges constant size rows according to the 'left_smaller' array
-	void MergeRows(data_ptr_t &l_ptr, idx_t &l_entry_idx, const idx_t &l_count, data_ptr_t &r_ptr, idx_t &r_entry_idx,
-	               const idx_t &r_count, RowDataBlock *target_block, data_ptr_t &target_ptr, const idx_t &entry_size,
-	               const bool left_smaller[], idx_t &copied, const idx_t &count);
-	//! Flushes constant size rows into the result
-	void FlushRows(data_ptr_t &source_ptr, idx_t &source_entry_idx, const idx_t &source_count,
-	               RowDataBlock *target_block, data_ptr_t &target_ptr, const idx_t &entry_size, idx_t &copied,
-	               const idx_t &count);
-	//! Flushes blob rows and accompanying heap
-	void FlushBlobs(const RowLayout &layout, const idx_t &source_count, data_ptr_t &source_data_ptr,
-	                idx_t &source_entry_idx, data_ptr_t &source_heap_ptr, RowDataBlock *target_data_block,
-	                data_ptr_t &target_data_ptr, RowDataBlock *target_heap_block, BufferHandle &target_heap_handle,
-	                data_ptr_t &target_heap_ptr, idx_t &copied, const idx_t &count);
-
-private:
-	//! The global sorting state
-	GlobalSortState &state;
-	//! The sorting and payload layouts
-	BufferManager &buffer_manager;
-	const SortLayout &sort_layout;
-
-	//! The left, right and result blocks of the current partition
-	unique_ptr<SortedBlock> left_block;
-	unique_ptr<SortedBlock> right_block;
-	SortedBlock *result;
-};
-
-} // namespace duckdb
-
-
-namespace duckdb {
-
-bool Comparators::TieIsBreakable(const idx_t &col_idx, const data_ptr_t row_ptr, const RowLayout &row_layout) {
-	// Check if the blob is NULL
-	ValidityBytes row_mask(row_ptr);
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	ValidityBytes::GetEntryIndex(col_idx, entry_idx, idx_in_entry);
-	if (!row_mask.RowIsValid(row_mask.GetValidityEntry(entry_idx), idx_in_entry)) {
-		// Can't break a NULL tie
-		return false;
-	}
-	if (row_layout.GetTypes()[col_idx].InternalType() == PhysicalType::VARCHAR) {
-		const auto &tie_col_offset = row_layout.GetOffsets()[col_idx];
-		string_t tie_string = Load<string_t>(row_ptr + tie_col_offset);
-		if (tie_string.GetSize() < string_t::INLINE_LENGTH) {
-			// No need to break the tie - we already compared the full string
-			return false;
-		}
-	}
-	return true;
-}
-
-int Comparators::CompareTuple(const SortedBlock &left, const SortedBlock &right, const data_ptr_t &l_ptr,
-                              const data_ptr_t &r_ptr, const SortLayout &sort_layout, const bool &external_sort) {
-	// Compare the sorting columns one by one
-	int comp_res = 0;
-	data_ptr_t l_ptr_offset = l_ptr;
-	data_ptr_t r_ptr_offset = r_ptr;
-	for (idx_t col_idx = 0; col_idx < sort_layout.column_count; col_idx++) {
-		comp_res = memcmp(l_ptr_offset, r_ptr_offset, sort_layout.column_sizes[col_idx]);
-		if (comp_res == 0 && !sort_layout.constant_size[col_idx]) {
-			comp_res =
-			    BreakBlobTie(col_idx, *left.blob_sorting_data, *right.blob_sorting_data, sort_layout, external_sort);
-		}
-		if (comp_res != 0) {
-			break;
-		}
-		l_ptr_offset += sort_layout.column_sizes[col_idx];
-		r_ptr_offset += sort_layout.column_sizes[col_idx];
-	}
-	return comp_res;
-}
-
-int Comparators::CompareVal(const data_ptr_t l_ptr, const data_ptr_t r_ptr, const LogicalType &type) {
-	switch (type.InternalType()) {
-	case PhysicalType::VARCHAR:
-		return TemplatedCompareVal<string_t>(l_ptr, r_ptr);
-	case PhysicalType::LIST:
-	case PhysicalType::STRUCT: {
-		auto l_nested_ptr = Load<data_ptr_t>(l_ptr);
-		auto r_nested_ptr = Load<data_ptr_t>(r_ptr);
-		return CompareValAndAdvance(l_nested_ptr, r_nested_ptr, type);
-	}
-	default:
-		throw NotImplementedException("Unimplemented CompareVal for type %s", type.ToString());
-	}
-}
-
-int Comparators::BreakBlobTie(const idx_t &tie_col, const SortedData &left, const SortedData &right,
-                              const SortLayout &sort_layout, const bool &external) {
-	const idx_t &col_idx = sort_layout.sorting_to_blob_col.at(tie_col);
-	data_ptr_t l_data_ptr = left.DataPtr();
-	data_ptr_t r_data_ptr = right.DataPtr();
-	if (!TieIsBreakable(col_idx, l_data_ptr, sort_layout.blob_layout)) {
-		// Quick check to see if ties can be broken
-		return 0;
-	}
-	// Align the pointers
-	const auto &tie_col_offset = sort_layout.blob_layout.GetOffsets()[col_idx];
-	l_data_ptr += tie_col_offset;
-	r_data_ptr += tie_col_offset;
-	// Do the comparison
-	const int order = sort_layout.order_types[tie_col] == OrderType::DESCENDING ? -1 : 1;
-	const auto &type = left.layout.GetTypes()[col_idx];
-	int result;
-	if (external) {
-		// Store heap pointers
-		data_ptr_t l_heap_ptr = left.HeapPtr();
-		data_ptr_t r_heap_ptr = right.HeapPtr();
-		// Unswizzle offset to pointer
-		UnswizzleSingleValue(l_data_ptr, l_heap_ptr, type);
-		UnswizzleSingleValue(r_data_ptr, r_heap_ptr, type);
-		// Compare
-		result = CompareVal(l_data_ptr, r_data_ptr, type);
-		// Swizzle the pointers back to offsets
-		SwizzleSingleValue(l_data_ptr, l_heap_ptr, type);
-		SwizzleSingleValue(r_data_ptr, r_heap_ptr, type);
-	} else {
-		result = CompareVal(l_data_ptr, r_data_ptr, type);
-	}
-	return order * result;
-}
-
-template <class T>
-int Comparators::TemplatedCompareVal(const data_ptr_t &left_ptr, const data_ptr_t &right_ptr) {
-	const auto left_val = Load<T>(left_ptr);
-	const auto right_val = Load<T>(right_ptr);
-	if (Equals::Operation<T>(left_val, right_val)) {
-		return 0;
-	} else if (LessThan::Operation<T>(left_val, right_val)) {
-		return -1;
-	} else {
-		return 1;
-	}
-}
-
-int Comparators::CompareValAndAdvance(data_ptr_t &l_ptr, data_ptr_t &r_ptr, const LogicalType &type) {
-	switch (type.InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return TemplatedCompareAndAdvance<int8_t>(l_ptr, r_ptr);
-	case PhysicalType::INT16:
-		return TemplatedCompareAndAdvance<int16_t>(l_ptr, r_ptr);
-	case PhysicalType::INT32:
-		return TemplatedCompareAndAdvance<int32_t>(l_ptr, r_ptr);
-	case PhysicalType::INT64:
-		return TemplatedCompareAndAdvance<int64_t>(l_ptr, r_ptr);
-	case PhysicalType::UINT8:
-		return TemplatedCompareAndAdvance<uint8_t>(l_ptr, r_ptr);
-	case PhysicalType::UINT16:
-		return TemplatedCompareAndAdvance<uint16_t>(l_ptr, r_ptr);
-	case PhysicalType::UINT32:
-		return TemplatedCompareAndAdvance<uint32_t>(l_ptr, r_ptr);
-	case PhysicalType::UINT64:
-		return TemplatedCompareAndAdvance<uint64_t>(l_ptr, r_ptr);
-	case PhysicalType::INT128:
-		return TemplatedCompareAndAdvance<hugeint_t>(l_ptr, r_ptr);
-	case PhysicalType::FLOAT:
-		return TemplatedCompareAndAdvance<float>(l_ptr, r_ptr);
-	case PhysicalType::DOUBLE:
-		return TemplatedCompareAndAdvance<double>(l_ptr, r_ptr);
-	case PhysicalType::INTERVAL:
-		return TemplatedCompareAndAdvance<interval_t>(l_ptr, r_ptr);
-	case PhysicalType::VARCHAR:
-		return CompareStringAndAdvance(l_ptr, r_ptr);
-	case PhysicalType::LIST:
-		return CompareListAndAdvance(l_ptr, r_ptr, ListType::GetChildType(type));
-	case PhysicalType::STRUCT:
-		return CompareStructAndAdvance(l_ptr, r_ptr, StructType::GetChildTypes(type));
-	default:
-		throw NotImplementedException("Unimplemented CompareValAndAdvance for type %s", type.ToString());
-	}
-}
-
-template <class T>
-int Comparators::TemplatedCompareAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr) {
-	auto result = TemplatedCompareVal<T>(left_ptr, right_ptr);
-	left_ptr += sizeof(T);
-	right_ptr += sizeof(T);
-	return result;
-}
-
-int Comparators::CompareStringAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr) {
-	// Construct the string_t
-	uint32_t left_string_size = Load<uint32_t>(left_ptr);
-	uint32_t right_string_size = Load<uint32_t>(right_ptr);
-	left_ptr += sizeof(uint32_t);
-	right_ptr += sizeof(uint32_t);
-	string_t left_val((const char *)left_ptr, left_string_size);
-	string_t right_val((const char *)right_ptr, right_string_size);
-	left_ptr += left_string_size;
-	right_ptr += right_string_size;
-	// Compare
-	return TemplatedCompareVal<string_t>((data_ptr_t)&left_val, (data_ptr_t)&right_val);
-}
-
-int Comparators::CompareStructAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr,
-                                         const child_list_t<LogicalType> &types) {
-	idx_t count = types.size();
-	// Load validity masks
-	ValidityBytes left_validity(left_ptr);
-	ValidityBytes right_validity(right_ptr);
-	left_ptr += (count + 7) / 8;
-	right_ptr += (count + 7) / 8;
-	// Initialize variables
-	bool left_valid;
-	bool right_valid;
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	// Compare
-	int comp_res = 0;
-	for (idx_t i = 0; i < count; i++) {
-		ValidityBytes::GetEntryIndex(i, entry_idx, idx_in_entry);
-		left_valid = left_validity.RowIsValid(left_validity.GetValidityEntry(entry_idx), idx_in_entry);
-		right_valid = right_validity.RowIsValid(right_validity.GetValidityEntry(entry_idx), idx_in_entry);
-		auto &type = types[i].second;
-		if ((left_valid && right_valid) || TypeIsConstantSize(type.InternalType())) {
-			comp_res = CompareValAndAdvance(left_ptr, right_ptr, types[i].second);
-		}
-		if (!left_valid && !right_valid) {
-			comp_res = 0;
-		} else if (!left_valid) {
-			comp_res = 1;
-		} else if (!right_valid) {
-			comp_res = -1;
-		}
-		if (comp_res != 0) {
-			break;
-		}
-	}
-	return comp_res;
-}
-
-int Comparators::CompareListAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr, const LogicalType &type) {
-	// Load list lengths
-	auto left_len = Load<idx_t>(left_ptr);
-	auto right_len = Load<idx_t>(right_ptr);
-	left_ptr += sizeof(idx_t);
-	right_ptr += sizeof(idx_t);
-	// Load list validity masks
-	ValidityBytes left_validity(left_ptr);
-	ValidityBytes right_validity(right_ptr);
-	left_ptr += (left_len + 7) / 8;
-	right_ptr += (right_len + 7) / 8;
-	// Compare
-	int comp_res = 0;
-	idx_t count = MinValue(left_len, right_len);
-	if (TypeIsConstantSize(type.InternalType())) {
-		// Templated code for fixed-size types
-		switch (type.InternalType()) {
-		case PhysicalType::BOOL:
-		case PhysicalType::INT8:
-			comp_res = TemplatedCompareListLoop<int8_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::INT16:
-			comp_res = TemplatedCompareListLoop<int16_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::INT32:
-			comp_res = TemplatedCompareListLoop<int32_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::INT64:
-			comp_res = TemplatedCompareListLoop<int64_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::UINT8:
-			comp_res = TemplatedCompareListLoop<uint8_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::UINT16:
-			comp_res = TemplatedCompareListLoop<uint16_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::UINT32:
-			comp_res = TemplatedCompareListLoop<uint32_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::UINT64:
-			comp_res = TemplatedCompareListLoop<uint64_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::INT128:
-			comp_res = TemplatedCompareListLoop<hugeint_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::FLOAT:
-			comp_res = TemplatedCompareListLoop<float>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::DOUBLE:
-			comp_res = TemplatedCompareListLoop<double>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		case PhysicalType::INTERVAL:
-			comp_res = TemplatedCompareListLoop<interval_t>(left_ptr, right_ptr, left_validity, right_validity, count);
-			break;
-		default:
-			throw NotImplementedException("CompareListAndAdvance for fixed-size type %s", type.ToString());
-		}
-	} else {
-		// Variable-sized list entries
-		bool left_valid;
-		bool right_valid;
-		idx_t entry_idx;
-		idx_t idx_in_entry;
-		// Size (in bytes) of all variable-sizes entries is stored before the entries begin,
-		// to make deserialization easier. We need to skip over them
-		left_ptr += left_len * sizeof(idx_t);
-		right_ptr += right_len * sizeof(idx_t);
-		for (idx_t i = 0; i < count; i++) {
-			ValidityBytes::GetEntryIndex(i, entry_idx, idx_in_entry);
-			left_valid = left_validity.RowIsValid(left_validity.GetValidityEntry(entry_idx), idx_in_entry);
-			right_valid = right_validity.RowIsValid(right_validity.GetValidityEntry(entry_idx), idx_in_entry);
-			if (left_valid && right_valid) {
-				switch (type.InternalType()) {
-				case PhysicalType::LIST:
-					comp_res = CompareListAndAdvance(left_ptr, right_ptr, ListType::GetChildType(type));
-					break;
-				case PhysicalType::VARCHAR:
-					comp_res = CompareStringAndAdvance(left_ptr, right_ptr);
-					break;
-				case PhysicalType::STRUCT:
-					comp_res = CompareStructAndAdvance(left_ptr, right_ptr, StructType::GetChildTypes(type));
-					break;
-				default:
-					throw NotImplementedException("CompareListAndAdvance for variable-size type %s", type.ToString());
-				}
-			} else if (!left_valid && !right_valid) {
-				comp_res = 0;
-			} else if (left_valid) {
-				comp_res = -1;
-			} else {
-				comp_res = 1;
-			}
-			if (comp_res != 0) {
-				break;
-			}
-		}
-	}
-	// All values that we looped over were equal
-	if (comp_res == 0 && left_len != right_len) {
-		// Smaller lists first
-		if (left_len < right_len) {
-			comp_res = -1;
-		} else {
-			comp_res = 1;
-		}
-	}
-	return comp_res;
-}
-
-template <class T>
-int Comparators::TemplatedCompareListLoop(data_ptr_t &left_ptr, data_ptr_t &right_ptr,
-                                          const ValidityBytes &left_validity, const ValidityBytes &right_validity,
-                                          const idx_t &count) {
-	int comp_res = 0;
-	bool left_valid;
-	bool right_valid;
-	idx_t entry_idx;
-	idx_t idx_in_entry;
-	for (idx_t i = 0; i < count; i++) {
-		ValidityBytes::GetEntryIndex(i, entry_idx, idx_in_entry);
-		left_valid = left_validity.RowIsValid(left_validity.GetValidityEntry(entry_idx), idx_in_entry);
-		right_valid = right_validity.RowIsValid(right_validity.GetValidityEntry(entry_idx), idx_in_entry);
-		comp_res = TemplatedCompareAndAdvance<T>(left_ptr, right_ptr);
-		if (!left_valid && !right_valid) {
-			comp_res = 0;
-		} else if (!left_valid) {
-			comp_res = 1;
-		} else if (!right_valid) {
-			comp_res = -1;
-		}
-		if (comp_res != 0) {
-			break;
-		}
-	}
-	return comp_res;
-}
-
-void Comparators::UnswizzleSingleValue(data_ptr_t data_ptr, const data_ptr_t &heap_ptr, const LogicalType &type) {
-	if (type.InternalType() == PhysicalType::VARCHAR) {
-		data_ptr += sizeof(uint32_t) + string_t::PREFIX_LENGTH;
-	}
-	Store<data_ptr_t>(heap_ptr + Load<idx_t>(data_ptr), data_ptr);
-}
-
-void Comparators::SwizzleSingleValue(data_ptr_t data_ptr, const data_ptr_t &heap_ptr, const LogicalType &type) {
-	if (type.InternalType() == PhysicalType::VARCHAR) {
-		data_ptr += sizeof(uint32_t) + string_t::PREFIX_LENGTH;
-	}
-	Store<idx_t>(Load<data_ptr_t>(data_ptr) - heap_ptr, data_ptr);
-}
-
-} // namespace duckdb
-//                         DuckDB
-//
-// duckdb/common/fast_mem.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-template <size_t SIZE>
-static inline void MemcpyFixed(void *dest, const void *src) {
-	memcpy(dest, src, SIZE);
-}
-
-template <size_t SIZE>
-static inline int MemcmpFixed(const void *str1, const void *str2) {
-	return memcmp(str1, str2, SIZE);
-}
+template <size_t SIZE>
+static inline int MemcmpFixed(const void *str1, const void *str2) {
+	return memcmp(str1, str2, SIZE);
+}
 
 namespace duckdb {
 
@@ -30408,151 +29713,847 @@ static inline void FastMemcpy(void *dest, const void *src, const size_t size) {
 	case 256:
 		return MemcpyFixed<256>(dest, src);
 	default:
-		memcpy(dest, src, size);
+		memcpy(dest, src, size);
+	}
+	// LCOV_EXCL_STOP
+}
+
+//! This templated memcmp is significantly faster than std::memcmp,
+//! but only when you are calling memcmp with a const size in a loop.
+//! For instance `while (<cond>) { memcmp(<str1>, <str2>, const_size); ... }`
+static inline int FastMemcmp(const void *str1, const void *str2, const size_t size) {
+	// LCOV_EXCL_START
+	switch (size) {
+	case 0:
+		return 0;
+	case 1:
+		return MemcmpFixed<1>(str1, str2);
+	case 2:
+		return MemcmpFixed<2>(str1, str2);
+	case 3:
+		return MemcmpFixed<3>(str1, str2);
+	case 4:
+		return MemcmpFixed<4>(str1, str2);
+	case 5:
+		return MemcmpFixed<5>(str1, str2);
+	case 6:
+		return MemcmpFixed<6>(str1, str2);
+	case 7:
+		return MemcmpFixed<7>(str1, str2);
+	case 8:
+		return MemcmpFixed<8>(str1, str2);
+	case 9:
+		return MemcmpFixed<9>(str1, str2);
+	case 10:
+		return MemcmpFixed<10>(str1, str2);
+	case 11:
+		return MemcmpFixed<11>(str1, str2);
+	case 12:
+		return MemcmpFixed<12>(str1, str2);
+	case 13:
+		return MemcmpFixed<13>(str1, str2);
+	case 14:
+		return MemcmpFixed<14>(str1, str2);
+	case 15:
+		return MemcmpFixed<15>(str1, str2);
+	case 16:
+		return MemcmpFixed<16>(str1, str2);
+	case 17:
+		return MemcmpFixed<17>(str1, str2);
+	case 18:
+		return MemcmpFixed<18>(str1, str2);
+	case 19:
+		return MemcmpFixed<19>(str1, str2);
+	case 20:
+		return MemcmpFixed<20>(str1, str2);
+	case 21:
+		return MemcmpFixed<21>(str1, str2);
+	case 22:
+		return MemcmpFixed<22>(str1, str2);
+	case 23:
+		return MemcmpFixed<23>(str1, str2);
+	case 24:
+		return MemcmpFixed<24>(str1, str2);
+	case 25:
+		return MemcmpFixed<25>(str1, str2);
+	case 26:
+		return MemcmpFixed<26>(str1, str2);
+	case 27:
+		return MemcmpFixed<27>(str1, str2);
+	case 28:
+		return MemcmpFixed<28>(str1, str2);
+	case 29:
+		return MemcmpFixed<29>(str1, str2);
+	case 30:
+		return MemcmpFixed<30>(str1, str2);
+	case 31:
+		return MemcmpFixed<31>(str1, str2);
+	case 32:
+		return MemcmpFixed<32>(str1, str2);
+	case 33:
+		return MemcmpFixed<33>(str1, str2);
+	case 34:
+		return MemcmpFixed<34>(str1, str2);
+	case 35:
+		return MemcmpFixed<35>(str1, str2);
+	case 36:
+		return MemcmpFixed<36>(str1, str2);
+	case 37:
+		return MemcmpFixed<37>(str1, str2);
+	case 38:
+		return MemcmpFixed<38>(str1, str2);
+	case 39:
+		return MemcmpFixed<39>(str1, str2);
+	case 40:
+		return MemcmpFixed<40>(str1, str2);
+	case 41:
+		return MemcmpFixed<41>(str1, str2);
+	case 42:
+		return MemcmpFixed<42>(str1, str2);
+	case 43:
+		return MemcmpFixed<43>(str1, str2);
+	case 44:
+		return MemcmpFixed<44>(str1, str2);
+	case 45:
+		return MemcmpFixed<45>(str1, str2);
+	case 46:
+		return MemcmpFixed<46>(str1, str2);
+	case 47:
+		return MemcmpFixed<47>(str1, str2);
+	case 48:
+		return MemcmpFixed<48>(str1, str2);
+	case 49:
+		return MemcmpFixed<49>(str1, str2);
+	case 50:
+		return MemcmpFixed<50>(str1, str2);
+	case 51:
+		return MemcmpFixed<51>(str1, str2);
+	case 52:
+		return MemcmpFixed<52>(str1, str2);
+	case 53:
+		return MemcmpFixed<53>(str1, str2);
+	case 54:
+		return MemcmpFixed<54>(str1, str2);
+	case 55:
+		return MemcmpFixed<55>(str1, str2);
+	case 56:
+		return MemcmpFixed<56>(str1, str2);
+	case 57:
+		return MemcmpFixed<57>(str1, str2);
+	case 58:
+		return MemcmpFixed<58>(str1, str2);
+	case 59:
+		return MemcmpFixed<59>(str1, str2);
+	case 60:
+		return MemcmpFixed<60>(str1, str2);
+	case 61:
+		return MemcmpFixed<61>(str1, str2);
+	case 62:
+		return MemcmpFixed<62>(str1, str2);
+	case 63:
+		return MemcmpFixed<63>(str1, str2);
+	case 64:
+		return MemcmpFixed<64>(str1, str2);
+	default:
+		return memcmp(str1, str2, size);
+	}
+	// LCOV_EXCL_STOP
+}
+
+} // namespace duckdb
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/sort/sort.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/sort/sorted_block.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+namespace duckdb {
+
+class BufferManager;
+struct RowDataBlock;
+struct SortLayout;
+struct GlobalSortState;
+
+//! Object that holds sorted rows, and an accompanying heap if there are blobs
+struct SortedData {
+public:
+	SortedData(const RowLayout &layout, BufferManager &buffer_manager, GlobalSortState &state);
+	//! Number of rows that this object holds
+	idx_t Count();
+	//! Pin the current block so it can be read
+	void Pin();
+	//! Pointer to the row that is currently being read from
+	data_ptr_t DataPtr() const;
+	//! Pointer to the heap row that corresponds to the current row
+	data_ptr_t HeapPtr() const;
+	//! Advance one row
+	void Advance(const bool &adv);
+	//! Initialize new block to write to
+	void CreateBlock();
+	//! Reset read indices to the given indices
+	void ResetIndices(idx_t block_idx_to, idx_t entry_idx_to);
+	//! Create a slice that holds the rows between the start and end indices
+	unique_ptr<SortedData> CreateSlice(idx_t start_block_index, idx_t start_entry_index, idx_t end_block_index,
+	                                   idx_t end_entry_index);
+	//! Unswizzles all
+	void Unswizzle();
+
+public:
+	//! Layout of this data
+	const RowLayout layout;
+	//! Data and heap blocks
+	vector<RowDataBlock> data_blocks;
+	vector<RowDataBlock> heap_blocks;
+	//! Buffer handles to the data being currently read
+	unique_ptr<BufferHandle> data_handle;
+	unique_ptr<BufferHandle> heap_handle;
+	//! Read indices
+	idx_t block_idx;
+	idx_t entry_idx;
+	//! Whether the pointers in this sorted data are swizzled
+	bool swizzled;
+
+private:
+	//! Pin fixed-size row data
+	void PinData();
+	//! Pin the accompanying heap data (if any)
+	void PinHeap();
+
+private:
+	//! The buffer manager
+	BufferManager &buffer_manager;
+	//! The global state
+	GlobalSortState &state;
+	//! Pointers into the buffers being currently read
+	data_ptr_t data_ptr;
+	data_ptr_t heap_ptr;
+};
+
+//! Block that holds sorted rows: radix, blob and payload data
+struct SortedBlock {
+public:
+	SortedBlock(BufferManager &buffer_manager, GlobalSortState &gstate);
+	//! Number of rows that this object holds
+	idx_t Count() const;
+	//! The remaining number of rows to be read from this object
+	idx_t Remaining() const;
+	//! Initialize this block to write data to
+	void InitializeWrite();
+	//! Init new block to write to
+	void CreateBlock();
+	//! Pins radix block with given index
+	void PinRadix(idx_t pin_block_idx);
+	//! Fill this sorted block by appending the blocks held by a vector of sorted blocks
+	void AppendSortedBlocks(vector<unique_ptr<SortedBlock>> &sorted_blocks);
+	//! Locate the block and entry index of a row in this block,
+	//! given an index between 0 and the total number of rows in this block
+	void GlobalToLocalIndex(const idx_t &global_idx, idx_t &local_block_index, idx_t &local_entry_index);
+	//! Create a slice that holds the rows between the start and end indices
+	unique_ptr<SortedBlock> CreateSlice(const idx_t start, const idx_t end);
+
+	//! Size (in bytes) of the heap of this block
+	idx_t HeapSize() const;
+	//! Total size (in bytes) of this block
+	idx_t SizeInBytes() const;
+
+public:
+	//! Radix/memcmp sortable data
+	vector<RowDataBlock> radix_sorting_data;
+	unique_ptr<BufferHandle> radix_handle;
+	idx_t block_idx;
+	idx_t entry_idx;
+	//! Variable sized sorting data
+	unique_ptr<SortedData> blob_sorting_data;
+	//! Payload data
+	unique_ptr<SortedData> payload_data;
+
+private:
+	//! Buffer manager, and sorting layout constants
+	BufferManager &buffer_manager;
+	GlobalSortState &state;
+	const SortLayout &sort_layout;
+	const RowLayout &payload_layout;
+};
+
+struct SortedDataScanner {
+public:
+	SortedDataScanner(SortedData &sorted_data, GlobalSortState &global_sort_state);
+
+	//! Scans the next data chunk from the sorted data
+	void Scan(DataChunk &chunk);
+
+private:
+	//! The sorted data being scanned
+	SortedData &sorted_data;
+	//! The total count of sorted_data
+	const idx_t total_count;
+	//! The global sort state
+	GlobalSortState &global_sort_state;
+	//! Addresses used to gather from the sorted data
+	Vector addresses = Vector(LogicalType::POINTER);
+	//! The number of rows scanned so far
+	idx_t total_scanned;
+};
+
+} // namespace duckdb
+
+
+
+
+namespace duckdb {
+
+class RowLayout;
+struct LocalSortState;
+
+struct SortConstants {
+	static constexpr idx_t VALUES_PER_RADIX = 256;
+	static constexpr idx_t MSD_RADIX_LOCATIONS = VALUES_PER_RADIX + 1;
+	static constexpr idx_t INSERTION_SORT_THRESHOLD = 24;
+	static constexpr idx_t MSD_RADIX_SORT_SIZE_THRESHOLD = 4;
+};
+
+struct SortLayout {
+public:
+	explicit SortLayout(const vector<BoundOrderByNode> &orders);
+
+public:
+	idx_t column_count;
+	vector<OrderType> order_types;
+	vector<OrderByNullType> order_by_null_types;
+	vector<LogicalType> logical_types;
+
+	bool all_constant;
+	vector<bool> constant_size;
+	vector<idx_t> column_sizes;
+	vector<idx_t> prefix_lengths;
+	vector<BaseStatistics *> stats;
+	vector<bool> has_null;
+
+	idx_t comparison_size;
+	idx_t entry_size;
+
+	RowLayout blob_layout;
+	unordered_map<idx_t, idx_t> sorting_to_blob_col;
+};
+
+struct GlobalSortState {
+public:
+	GlobalSortState(BufferManager &buffer_manager, const vector<BoundOrderByNode> &orders, RowLayout &payload_layout);
+
+	//! Add local state sorted data to this global state
+	void AddLocalState(LocalSortState &local_sort_state);
+	//! Prepares the GlobalSortState for the merge sort phase (after completing radix sort phase)
+	void PrepareMergePhase();
+	//! Initializes the global sort state for another round of merging
+	void InitializeMergeRound();
+	//! Completes the cascaded merge sort round
+	void CompleteMergeRound();
+
+public:
+	//! The lock for updating the order global state
+	mutex lock;
+	//! The buffer manager
+	BufferManager &buffer_manager;
+
+	//! Sorting and payload layouts
+	const SortLayout sort_layout;
+	const RowLayout payload_layout;
+
+	//! Sorted data
+	vector<unique_ptr<SortedBlock>> sorted_blocks;
+	vector<vector<unique_ptr<SortedBlock>>> sorted_blocks_temp;
+	unique_ptr<SortedBlock> odd_one_out;
+
+	//! Pinned heap data (if sorting in memory)
+	vector<RowDataBlock> heap_blocks;
+	vector<unique_ptr<BufferHandle>> pinned_blocks;
+
+	//! Capacity (number of rows) used to initialize blocks
+	idx_t block_capacity;
+	//! Whether we are doing an external sort
+	bool external;
+
+	//! Progress in merge path stage
+	idx_t pair_idx;
+	idx_t num_pairs;
+	idx_t l_start;
+	idx_t r_start;
+};
+
+struct LocalSortState {
+public:
+	LocalSortState();
+
+	//! Initialize the layouts and RowDataCollections
+	void Initialize(GlobalSortState &global_sort_state, BufferManager &buffer_manager_p);
+	//! Sink one DataChunk into the local sort state
+	void SinkChunk(DataChunk &sort, DataChunk &payload);
+	//! Size of accumulated data in bytes
+	idx_t SizeInBytes() const;
+	//! Sort the data accumulated so far
+	void Sort(GlobalSortState &global_sort_state, bool reorder_heap);
+
+private:
+	//! Concatenate the blocks held by a RowDataCollection into a single block
+	RowDataBlock ConcatenateBlocks(RowDataCollection &row_data);
+	//! Sorts the data in the newly created SortedBlock
+	void SortInMemory();
+	//! Re-order the local state after sorting
+	void ReOrder(GlobalSortState &gstate, bool reorder_heap);
+	//! Re-order a SortedData object after sorting
+	void ReOrder(SortedData &sd, data_ptr_t sorting_ptr, RowDataCollection &heap, GlobalSortState &gstate,
+	             bool reorder_heap);
+
+public:
+	//! Whether this local state has been initialized
+	bool initialized;
+	//! The buffer manager
+	BufferManager *buffer_manager;
+	//! The sorting and payload layouts
+	const SortLayout *sort_layout;
+	const RowLayout *payload_layout;
+	//! Radix/memcmp sortable data
+	unique_ptr<RowDataCollection> radix_sorting_data;
+	//! Variable sized sorting data and accompanying heap
+	unique_ptr<RowDataCollection> blob_sorting_data;
+	unique_ptr<RowDataCollection> blob_sorting_heap;
+	//! Payload data and accompanying heap
+	unique_ptr<RowDataCollection> payload_data;
+	unique_ptr<RowDataCollection> payload_heap;
+	//! Sorted data
+	vector<unique_ptr<SortedBlock>> sorted_blocks;
+
+private:
+	//! Selection vector and addresses for scattering the data to rows
+	const SelectionVector &sel_ptr = FlatVector::INCREMENTAL_SELECTION_VECTOR;
+	Vector addresses = Vector(LogicalType::POINTER);
+};
+
+struct MergeSorter {
+public:
+	MergeSorter(GlobalSortState &state, BufferManager &buffer_manager);
+
+	//! Finds and merges partitions until the current cascaded merge round is finished
+	void PerformInMergeRound();
+
+private:
+	//! Computes the left and right block that will be merged next (Merge Path partition)
+	void GetNextPartition();
+	//! Finds the boundary of the next partition using binary search
+	void GetIntersection(SortedBlock &l, SortedBlock &r, const idx_t diagonal, idx_t &l_idx, idx_t &r_idx);
+	//! Compare values within SortedBlocks using a global index
+	int CompareUsingGlobalIndex(SortedBlock &l, SortedBlock &r, const idx_t l_idx, const idx_t r_idx);
+
+	//! Finds the next partition and merges it
+	void MergePartition();
+
+	//! Computes how the next 'count' tuples should be merged by setting the 'left_smaller' array
+	void ComputeMerge(const idx_t &count, bool left_smaller[]);
+
+	//! Merges the radix sorting blocks according to the 'left_smaller' array
+	void MergeRadix(const idx_t &count, const bool left_smaller[]);
+	//! Merges SortedData according to the 'left_smaller' array
+	void MergeData(SortedData &result_data, SortedData &l_data, SortedData &r_data, const idx_t &count,
+	               const bool left_smaller[], idx_t next_entry_sizes[]);
+	//! Merges constant size rows according to the 'left_smaller' array
+	void MergeRows(data_ptr_t &l_ptr, idx_t &l_entry_idx, const idx_t &l_count, data_ptr_t &r_ptr, idx_t &r_entry_idx,
+	               const idx_t &r_count, RowDataBlock *target_block, data_ptr_t &target_ptr, const idx_t &entry_size,
+	               const bool left_smaller[], idx_t &copied, const idx_t &count);
+	//! Flushes constant size rows into the result
+	void FlushRows(data_ptr_t &source_ptr, idx_t &source_entry_idx, const idx_t &source_count,
+	               RowDataBlock *target_block, data_ptr_t &target_ptr, const idx_t &entry_size, idx_t &copied,
+	               const idx_t &count);
+	//! Flushes blob rows and accompanying heap
+	void FlushBlobs(const RowLayout &layout, const idx_t &source_count, data_ptr_t &source_data_ptr,
+	                idx_t &source_entry_idx, data_ptr_t &source_heap_ptr, RowDataBlock *target_data_block,
+	                data_ptr_t &target_data_ptr, RowDataBlock *target_heap_block, BufferHandle &target_heap_handle,
+	                data_ptr_t &target_heap_ptr, idx_t &copied, const idx_t &count);
+
+private:
+	//! The global sorting state
+	GlobalSortState &state;
+	//! The sorting and payload layouts
+	BufferManager &buffer_manager;
+	const SortLayout &sort_layout;
+
+	//! The left, right and result blocks of the current partition
+	unique_ptr<SortedBlock> left_block;
+	unique_ptr<SortedBlock> right_block;
+	SortedBlock *result;
+};
+
+} // namespace duckdb
+
+
+namespace duckdb {
+
+bool Comparators::TieIsBreakable(const idx_t &col_idx, const data_ptr_t row_ptr, const RowLayout &row_layout) {
+	// Check if the blob is NULL
+	ValidityBytes row_mask(row_ptr);
+	idx_t entry_idx;
+	idx_t idx_in_entry;
+	ValidityBytes::GetEntryIndex(col_idx, entry_idx, idx_in_entry);
+	if (!row_mask.RowIsValid(row_mask.GetValidityEntry(entry_idx), idx_in_entry)) {
+		// Can't break a NULL tie
+		return false;
+	}
+	if (row_layout.GetTypes()[col_idx].InternalType() == PhysicalType::VARCHAR) {
+		const auto &tie_col_offset = row_layout.GetOffsets()[col_idx];
+		string_t tie_string = Load<string_t>(row_ptr + tie_col_offset);
+		if (tie_string.GetSize() < string_t::INLINE_LENGTH) {
+			// No need to break the tie - we already compared the full string
+			return false;
+		}
+	}
+	return true;
+}
+
+int Comparators::CompareTuple(const SortedBlock &left, const SortedBlock &right, const data_ptr_t &l_ptr,
+                              const data_ptr_t &r_ptr, const SortLayout &sort_layout, const bool &external_sort) {
+	// Compare the sorting columns one by one
+	int comp_res = 0;
+	data_ptr_t l_ptr_offset = l_ptr;
+	data_ptr_t r_ptr_offset = r_ptr;
+	for (idx_t col_idx = 0; col_idx < sort_layout.column_count; col_idx++) {
+		comp_res = FastMemcmp(l_ptr_offset, r_ptr_offset, sort_layout.column_sizes[col_idx]);
+		if (comp_res == 0 && !sort_layout.constant_size[col_idx]) {
+			comp_res =
+			    BreakBlobTie(col_idx, *left.blob_sorting_data, *right.blob_sorting_data, sort_layout, external_sort);
+		}
+		if (comp_res != 0) {
+			break;
+		}
+		l_ptr_offset += sort_layout.column_sizes[col_idx];
+		r_ptr_offset += sort_layout.column_sizes[col_idx];
+	}
+	return comp_res;
+}
+
+int Comparators::CompareVal(const data_ptr_t l_ptr, const data_ptr_t r_ptr, const LogicalType &type) {
+	switch (type.InternalType()) {
+	case PhysicalType::VARCHAR:
+		return TemplatedCompareVal<string_t>(l_ptr, r_ptr);
+	case PhysicalType::LIST:
+	case PhysicalType::STRUCT: {
+		auto l_nested_ptr = Load<data_ptr_t>(l_ptr);
+		auto r_nested_ptr = Load<data_ptr_t>(r_ptr);
+		return CompareValAndAdvance(l_nested_ptr, r_nested_ptr, type);
+	}
+	default:
+		throw NotImplementedException("Unimplemented CompareVal for type %s", type.ToString());
+	}
+}
+
+int Comparators::BreakBlobTie(const idx_t &tie_col, const SortedData &left, const SortedData &right,
+                              const SortLayout &sort_layout, const bool &external) {
+	const idx_t &col_idx = sort_layout.sorting_to_blob_col.at(tie_col);
+	data_ptr_t l_data_ptr = left.DataPtr();
+	data_ptr_t r_data_ptr = right.DataPtr();
+	if (!TieIsBreakable(col_idx, l_data_ptr, sort_layout.blob_layout)) {
+		// Quick check to see if ties can be broken
+		return 0;
+	}
+	// Align the pointers
+	const auto &tie_col_offset = sort_layout.blob_layout.GetOffsets()[col_idx];
+	l_data_ptr += tie_col_offset;
+	r_data_ptr += tie_col_offset;
+	// Do the comparison
+	const int order = sort_layout.order_types[tie_col] == OrderType::DESCENDING ? -1 : 1;
+	const auto &type = left.layout.GetTypes()[col_idx];
+	int result;
+	if (external) {
+		// Store heap pointers
+		data_ptr_t l_heap_ptr = left.HeapPtr();
+		data_ptr_t r_heap_ptr = right.HeapPtr();
+		// Unswizzle offset to pointer
+		UnswizzleSingleValue(l_data_ptr, l_heap_ptr, type);
+		UnswizzleSingleValue(r_data_ptr, r_heap_ptr, type);
+		// Compare
+		result = CompareVal(l_data_ptr, r_data_ptr, type);
+		// Swizzle the pointers back to offsets
+		SwizzleSingleValue(l_data_ptr, l_heap_ptr, type);
+		SwizzleSingleValue(r_data_ptr, r_heap_ptr, type);
+	} else {
+		result = CompareVal(l_data_ptr, r_data_ptr, type);
+	}
+	return order * result;
+}
+
+template <class T>
+int Comparators::TemplatedCompareVal(const data_ptr_t &left_ptr, const data_ptr_t &right_ptr) {
+	const auto left_val = Load<T>(left_ptr);
+	const auto right_val = Load<T>(right_ptr);
+	if (Equals::Operation<T>(left_val, right_val)) {
+		return 0;
+	} else if (LessThan::Operation<T>(left_val, right_val)) {
+		return -1;
+	} else {
+		return 1;
+	}
+}
+
+int Comparators::CompareValAndAdvance(data_ptr_t &l_ptr, data_ptr_t &r_ptr, const LogicalType &type) {
+	switch (type.InternalType()) {
+	case PhysicalType::BOOL:
+	case PhysicalType::INT8:
+		return TemplatedCompareAndAdvance<int8_t>(l_ptr, r_ptr);
+	case PhysicalType::INT16:
+		return TemplatedCompareAndAdvance<int16_t>(l_ptr, r_ptr);
+	case PhysicalType::INT32:
+		return TemplatedCompareAndAdvance<int32_t>(l_ptr, r_ptr);
+	case PhysicalType::INT64:
+		return TemplatedCompareAndAdvance<int64_t>(l_ptr, r_ptr);
+	case PhysicalType::UINT8:
+		return TemplatedCompareAndAdvance<uint8_t>(l_ptr, r_ptr);
+	case PhysicalType::UINT16:
+		return TemplatedCompareAndAdvance<uint16_t>(l_ptr, r_ptr);
+	case PhysicalType::UINT32:
+		return TemplatedCompareAndAdvance<uint32_t>(l_ptr, r_ptr);
+	case PhysicalType::UINT64:
+		return TemplatedCompareAndAdvance<uint64_t>(l_ptr, r_ptr);
+	case PhysicalType::INT128:
+		return TemplatedCompareAndAdvance<hugeint_t>(l_ptr, r_ptr);
+	case PhysicalType::FLOAT:
+		return TemplatedCompareAndAdvance<float>(l_ptr, r_ptr);
+	case PhysicalType::DOUBLE:
+		return TemplatedCompareAndAdvance<double>(l_ptr, r_ptr);
+	case PhysicalType::INTERVAL:
+		return TemplatedCompareAndAdvance<interval_t>(l_ptr, r_ptr);
+	case PhysicalType::VARCHAR:
+		return CompareStringAndAdvance(l_ptr, r_ptr);
+	case PhysicalType::LIST:
+		return CompareListAndAdvance(l_ptr, r_ptr, ListType::GetChildType(type));
+	case PhysicalType::STRUCT:
+		return CompareStructAndAdvance(l_ptr, r_ptr, StructType::GetChildTypes(type));
+	default:
+		throw NotImplementedException("Unimplemented CompareValAndAdvance for type %s", type.ToString());
+	}
+}
+
+template <class T>
+int Comparators::TemplatedCompareAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr) {
+	auto result = TemplatedCompareVal<T>(left_ptr, right_ptr);
+	left_ptr += sizeof(T);
+	right_ptr += sizeof(T);
+	return result;
+}
+
+int Comparators::CompareStringAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr) {
+	// Construct the string_t
+	uint32_t left_string_size = Load<uint32_t>(left_ptr);
+	uint32_t right_string_size = Load<uint32_t>(right_ptr);
+	left_ptr += sizeof(uint32_t);
+	right_ptr += sizeof(uint32_t);
+	string_t left_val((const char *)left_ptr, left_string_size);
+	string_t right_val((const char *)right_ptr, right_string_size);
+	left_ptr += left_string_size;
+	right_ptr += right_string_size;
+	// Compare
+	return TemplatedCompareVal<string_t>((data_ptr_t)&left_val, (data_ptr_t)&right_val);
+}
+
+int Comparators::CompareStructAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr,
+                                         const child_list_t<LogicalType> &types) {
+	idx_t count = types.size();
+	// Load validity masks
+	ValidityBytes left_validity(left_ptr);
+	ValidityBytes right_validity(right_ptr);
+	left_ptr += (count + 7) / 8;
+	right_ptr += (count + 7) / 8;
+	// Initialize variables
+	bool left_valid;
+	bool right_valid;
+	idx_t entry_idx;
+	idx_t idx_in_entry;
+	// Compare
+	int comp_res = 0;
+	for (idx_t i = 0; i < count; i++) {
+		ValidityBytes::GetEntryIndex(i, entry_idx, idx_in_entry);
+		left_valid = left_validity.RowIsValid(left_validity.GetValidityEntry(entry_idx), idx_in_entry);
+		right_valid = right_validity.RowIsValid(right_validity.GetValidityEntry(entry_idx), idx_in_entry);
+		auto &type = types[i].second;
+		if ((left_valid && right_valid) || TypeIsConstantSize(type.InternalType())) {
+			comp_res = CompareValAndAdvance(left_ptr, right_ptr, types[i].second);
+		}
+		if (!left_valid && !right_valid) {
+			comp_res = 0;
+		} else if (!left_valid) {
+			comp_res = 1;
+		} else if (!right_valid) {
+			comp_res = -1;
+		}
+		if (comp_res != 0) {
+			break;
+		}
+	}
+	return comp_res;
+}
+
+int Comparators::CompareListAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr, const LogicalType &type) {
+	// Load list lengths
+	auto left_len = Load<idx_t>(left_ptr);
+	auto right_len = Load<idx_t>(right_ptr);
+	left_ptr += sizeof(idx_t);
+	right_ptr += sizeof(idx_t);
+	// Load list validity masks
+	ValidityBytes left_validity(left_ptr);
+	ValidityBytes right_validity(right_ptr);
+	left_ptr += (left_len + 7) / 8;
+	right_ptr += (right_len + 7) / 8;
+	// Compare
+	int comp_res = 0;
+	idx_t count = MinValue(left_len, right_len);
+	if (TypeIsConstantSize(type.InternalType())) {
+		// Templated code for fixed-size types
+		switch (type.InternalType()) {
+		case PhysicalType::BOOL:
+		case PhysicalType::INT8:
+			comp_res = TemplatedCompareListLoop<int8_t>(left_ptr, right_ptr, left_validity, right_validity, count);
+			break;
+		case PhysicalType::INT16:
+			comp_res = TemplatedCompareListLoop<int16_t>(left_ptr, right_ptr, left_validity, right_validity, count);
+			break;
+		case PhysicalType::INT32:
+			comp_res = TemplatedCompareListLoop<int32_t>(left_ptr, right_ptr, left_validity, right_validity, count);
+			break;
+		case PhysicalType::INT64:
+			comp_res = TemplatedCompareListLoop<int64_t>(left_ptr, right_ptr, left_validity, right_validity, count);
+			break;
+		case PhysicalType::UINT8:
+			comp_res = TemplatedCompareListLoop<uint8_t>(left_ptr, right_ptr, left_validity, right_validity, count);
+			break;
+		case PhysicalType::UINT16:
+			comp_res = TemplatedCompareListLoop<uint16_t>(left_ptr, right_ptr, left_validity, right_validity, count);
+			break;
+		case PhysicalType::UINT32:
+			comp_res = TemplatedCompareListLoop<uint32_t>(left_ptr, right_ptr, left_validity, right_validity, count);
+			break;
+		case PhysicalType::UINT64:
+			comp_res = TemplatedCompareListLoop<uint64_t>(left_ptr, right_ptr, left_validity, right_validity, count);
+			break;
+		case PhysicalType::INT128:
+			comp_res = TemplatedCompareListLoop<hugeint_t>(left_ptr, right_ptr, left_validity, right_validity, count);
+			break;
+		case PhysicalType::FLOAT:
+			comp_res = TemplatedCompareListLoop<float>(left_ptr, right_ptr, left_validity, right_validity, count);
+			break;
+		case PhysicalType::DOUBLE:
+			comp_res = TemplatedCompareListLoop<double>(left_ptr, right_ptr, left_validity, right_validity, count);
+			break;
+		case PhysicalType::INTERVAL:
+			comp_res = TemplatedCompareListLoop<interval_t>(left_ptr, right_ptr, left_validity, right_validity, count);
+			break;
+		default:
+			throw NotImplementedException("CompareListAndAdvance for fixed-size type %s", type.ToString());
+		}
+	} else {
+		// Variable-sized list entries
+		bool left_valid;
+		bool right_valid;
+		idx_t entry_idx;
+		idx_t idx_in_entry;
+		// Size (in bytes) of all variable-sizes entries is stored before the entries begin,
+		// to make deserialization easier. We need to skip over them
+		left_ptr += left_len * sizeof(idx_t);
+		right_ptr += right_len * sizeof(idx_t);
+		for (idx_t i = 0; i < count; i++) {
+			ValidityBytes::GetEntryIndex(i, entry_idx, idx_in_entry);
+			left_valid = left_validity.RowIsValid(left_validity.GetValidityEntry(entry_idx), idx_in_entry);
+			right_valid = right_validity.RowIsValid(right_validity.GetValidityEntry(entry_idx), idx_in_entry);
+			if (left_valid && right_valid) {
+				switch (type.InternalType()) {
+				case PhysicalType::LIST:
+					comp_res = CompareListAndAdvance(left_ptr, right_ptr, ListType::GetChildType(type));
+					break;
+				case PhysicalType::VARCHAR:
+					comp_res = CompareStringAndAdvance(left_ptr, right_ptr);
+					break;
+				case PhysicalType::STRUCT:
+					comp_res = CompareStructAndAdvance(left_ptr, right_ptr, StructType::GetChildTypes(type));
+					break;
+				default:
+					throw NotImplementedException("CompareListAndAdvance for variable-size type %s", type.ToString());
+				}
+			} else if (!left_valid && !right_valid) {
+				comp_res = 0;
+			} else if (left_valid) {
+				comp_res = -1;
+			} else {
+				comp_res = 1;
+			}
+			if (comp_res != 0) {
+				break;
+			}
+		}
 	}
-	// LCOV_EXCL_STOP
+	// All values that we looped over were equal
+	if (comp_res == 0 && left_len != right_len) {
+		// Smaller lists first
+		if (left_len < right_len) {
+			comp_res = -1;
+		} else {
+			comp_res = 1;
+		}
+	}
+	return comp_res;
 }
 
-//! This templated memcmp is significantly faster than std::memcmp,
-//! but only when you are calling memcmp with a const size in a loop.
-//! For instance `while (<cond>) { memcmp(<str1>, <str2>, const_size); ... }`
-static inline int FastMemcmp(const void *str1, const void *str2, const size_t size) {
-	// LCOV_EXCL_START
-	switch (size) {
-	case 0:
-		return 0;
-	case 1:
-		return MemcmpFixed<1>(str1, str2);
-	case 2:
-		return MemcmpFixed<2>(str1, str2);
-	case 3:
-		return MemcmpFixed<3>(str1, str2);
-	case 4:
-		return MemcmpFixed<4>(str1, str2);
-	case 5:
-		return MemcmpFixed<5>(str1, str2);
-	case 6:
-		return MemcmpFixed<6>(str1, str2);
-	case 7:
-		return MemcmpFixed<7>(str1, str2);
-	case 8:
-		return MemcmpFixed<8>(str1, str2);
-	case 9:
-		return MemcmpFixed<9>(str1, str2);
-	case 10:
-		return MemcmpFixed<10>(str1, str2);
-	case 11:
-		return MemcmpFixed<11>(str1, str2);
-	case 12:
-		return MemcmpFixed<12>(str1, str2);
-	case 13:
-		return MemcmpFixed<13>(str1, str2);
-	case 14:
-		return MemcmpFixed<14>(str1, str2);
-	case 15:
-		return MemcmpFixed<15>(str1, str2);
-	case 16:
-		return MemcmpFixed<16>(str1, str2);
-	case 17:
-		return MemcmpFixed<17>(str1, str2);
-	case 18:
-		return MemcmpFixed<18>(str1, str2);
-	case 19:
-		return MemcmpFixed<19>(str1, str2);
-	case 20:
-		return MemcmpFixed<20>(str1, str2);
-	case 21:
-		return MemcmpFixed<21>(str1, str2);
-	case 22:
-		return MemcmpFixed<22>(str1, str2);
-	case 23:
-		return MemcmpFixed<23>(str1, str2);
-	case 24:
-		return MemcmpFixed<24>(str1, str2);
-	case 25:
-		return MemcmpFixed<25>(str1, str2);
-	case 26:
-		return MemcmpFixed<26>(str1, str2);
-	case 27:
-		return MemcmpFixed<27>(str1, str2);
-	case 28:
-		return MemcmpFixed<28>(str1, str2);
-	case 29:
-		return MemcmpFixed<29>(str1, str2);
-	case 30:
-		return MemcmpFixed<30>(str1, str2);
-	case 31:
-		return MemcmpFixed<31>(str1, str2);
-	case 32:
-		return MemcmpFixed<32>(str1, str2);
-	case 33:
-		return MemcmpFixed<33>(str1, str2);
-	case 34:
-		return MemcmpFixed<34>(str1, str2);
-	case 35:
-		return MemcmpFixed<35>(str1, str2);
-	case 36:
-		return MemcmpFixed<36>(str1, str2);
-	case 37:
-		return MemcmpFixed<37>(str1, str2);
-	case 38:
-		return MemcmpFixed<38>(str1, str2);
-	case 39:
-		return MemcmpFixed<39>(str1, str2);
-	case 40:
-		return MemcmpFixed<40>(str1, str2);
-	case 41:
-		return MemcmpFixed<41>(str1, str2);
-	case 42:
-		return MemcmpFixed<42>(str1, str2);
-	case 43:
-		return MemcmpFixed<43>(str1, str2);
-	case 44:
-		return MemcmpFixed<44>(str1, str2);
-	case 45:
-		return MemcmpFixed<45>(str1, str2);
-	case 46:
-		return MemcmpFixed<46>(str1, str2);
-	case 47:
-		return MemcmpFixed<47>(str1, str2);
-	case 48:
-		return MemcmpFixed<48>(str1, str2);
-	case 49:
-		return MemcmpFixed<49>(str1, str2);
-	case 50:
-		return MemcmpFixed<50>(str1, str2);
-	case 51:
-		return MemcmpFixed<51>(str1, str2);
-	case 52:
-		return MemcmpFixed<52>(str1, str2);
-	case 53:
-		return MemcmpFixed<53>(str1, str2);
-	case 54:
-		return MemcmpFixed<54>(str1, str2);
-	case 55:
-		return MemcmpFixed<55>(str1, str2);
-	case 56:
-		return MemcmpFixed<56>(str1, str2);
-	case 57:
-		return MemcmpFixed<57>(str1, str2);
-	case 58:
-		return MemcmpFixed<58>(str1, str2);
-	case 59:
-		return MemcmpFixed<59>(str1, str2);
-	case 60:
-		return MemcmpFixed<60>(str1, str2);
-	case 61:
-		return MemcmpFixed<61>(str1, str2);
-	case 62:
-		return MemcmpFixed<62>(str1, str2);
-	case 63:
-		return MemcmpFixed<63>(str1, str2);
-	case 64:
-		return MemcmpFixed<64>(str1, str2);
-	default:
-		return memcmp(str1, str2, size);
+template <class T>
+int Comparators::TemplatedCompareListLoop(data_ptr_t &left_ptr, data_ptr_t &right_ptr,
+                                          const ValidityBytes &left_validity, const ValidityBytes &right_validity,
+                                          const idx_t &count) {
+	int comp_res = 0;
+	bool left_valid;
+	bool right_valid;
+	idx_t entry_idx;
+	idx_t idx_in_entry;
+	for (idx_t i = 0; i < count; i++) {
+		ValidityBytes::GetEntryIndex(i, entry_idx, idx_in_entry);
+		left_valid = left_validity.RowIsValid(left_validity.GetValidityEntry(entry_idx), idx_in_entry);
+		right_valid = right_validity.RowIsValid(right_validity.GetValidityEntry(entry_idx), idx_in_entry);
+		comp_res = TemplatedCompareAndAdvance<T>(left_ptr, right_ptr);
+		if (!left_valid && !right_valid) {
+			comp_res = 0;
+		} else if (!left_valid) {
+			comp_res = 1;
+		} else if (!right_valid) {
+			comp_res = -1;
+		}
+		if (comp_res != 0) {
+			break;
+		}
 	}
-	// LCOV_EXCL_STOP
+	return comp_res;
+}
+
+void Comparators::UnswizzleSingleValue(data_ptr_t data_ptr, const data_ptr_t &heap_ptr, const LogicalType &type) {
+	if (type.InternalType() == PhysicalType::VARCHAR) {
+		data_ptr += sizeof(uint32_t) + string_t::PREFIX_LENGTH;
+	}
+	Store<data_ptr_t>(heap_ptr + Load<idx_t>(data_ptr), data_ptr);
+}
+
+void Comparators::SwizzleSingleValue(data_ptr_t data_ptr, const data_ptr_t &heap_ptr, const LogicalType &type) {
+	if (type.InternalType() == PhysicalType::VARCHAR) {
+		data_ptr += sizeof(uint32_t) + string_t::PREFIX_LENGTH;
+	}
+	Store<idx_t>(Load<data_ptr_t>(data_ptr) - heap_ptr, data_ptr);
 }
 
 } // namespace duckdb
@@ -31557,6 +31558,7 @@ void LocalSortState::SortInMemory() {
 
 
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -31932,7 +31934,7 @@ void LocalSortState::ReOrder(SortedData &sd, data_ptr_t sorting_ptr, RowDataColl
 	const idx_t sorting_entry_size = gstate.sort_layout.entry_size;
 	for (idx_t i = 0; i < count; i++) {
 		auto index = Load<uint32_t>(sorting_ptr);
-		memcpy(ordered_data_ptr, unordered_data_ptr + index * row_width, row_width);
+		FastMemcpy(ordered_data_ptr, unordered_data_ptr + index * row_width, row_width);
 		ordered_data_ptr += row_width;
 		sorting_ptr += sorting_entry_size;
 	}