duckdb 0.7.2-dev314.0 → 0.7.2-dev3154.0

package/src/duckdb/src/common/row_operations/row_gather.cpp

@@ -6,8 +6,9 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/operator/constant_operators.hpp"
 #include "duckdb/common/row_operations/row_operations.hpp"
-#include "duckdb/common/types/row_data_collection.hpp"
-#include "duckdb/common/types/row_layout.hpp"
+#include "duckdb/common/types/row/row_data_collection.hpp"
+#include "duckdb/common/types/row/row_layout.hpp"
+#include "duckdb/common/types/row/tuple_data_layout.hpp"
 
 namespace duckdb {
 
@@ -193,7 +194,8 @@ static void TemplatedFullScanLoop(Vector &rows, Vector &col, idx_t count, idx_t
 	}
 }
 
-void RowOperations::FullScanColumn(const RowLayout &layout, Vector &rows, Vector &col, idx_t count, idx_t col_no) {
+void RowOperations::FullScanColumn(const TupleDataLayout &layout, Vector &rows, Vector &col, idx_t count,
+                                   idx_t col_no) {
 	const auto col_offset = layout.GetOffsets()[col_no];
 	col.SetVectorType(VectorType::FLAT_VECTOR);
 	switch (col.GetType().InternalType()) {

package/src/duckdb/src/common/row_operations/row_heap_scatter.cpp

@@ -163,7 +163,7 @@ static void HeapScatterStringVector(Vector &v, idx_t vcount, const SelectionVect
 				Store<uint32_t>(string_entry.GetSize(), key_locations[i]);
 				key_locations[i] += sizeof(uint32_t);
 				// store the string
-				memcpy(key_locations[i], string_entry.GetDataUnsafe(), string_entry.GetSize());
+				memcpy(key_locations[i], string_entry.GetData(), string_entry.GetSize());
 				key_locations[i] += string_entry.GetSize();
 			}
 		}
@@ -181,7 +181,7 @@ static void HeapScatterStringVector(Vector &v, idx_t vcount, const SelectionVect
 				Store<uint32_t>(string_entry.GetSize(), key_locations[i]);
 				key_locations[i] += sizeof(uint32_t);
 				// store the string
-				memcpy(key_locations[i], string_entry.GetDataUnsafe(), string_entry.GetSize());
+				memcpy(key_locations[i], string_entry.GetData(), string_entry.GetSize());
 				key_locations[i] += string_entry.GetSize();
 			} else {
 				// set the validitymask

package/src/duckdb/src/common/row_operations/row_match.cpp

@@ -4,10 +4,10 @@
 //===--------------------------------------------------------------------===//
 
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/operator/constant_operators.hpp"
 #include "duckdb/common/operator/comparison_operators.hpp"
+#include "duckdb/common/operator/constant_operators.hpp"
 #include "duckdb/common/row_operations/row_operations.hpp"
-#include "duckdb/common/types/row_layout.hpp"
+#include "duckdb/common/types/row/tuple_data_collection.hpp"
 
 namespace duckdb {
 
@@ -118,12 +118,104 @@ static void TemplatedMatchType(UnifiedVectorFormat &col, Vector &rows, Selection
 	count = match_count;
 }
 
+//! Forward declaration for recursion
+template <class OP, bool NO_MATCH_SEL>
+static void TemplatedMatchOp(Vector &vec, UnifiedVectorFormat &col, const TupleDataLayout &layout, Vector &rows,
+                             SelectionVector &sel, idx_t &count, idx_t col_no, SelectionVector *no_match,
+                             idx_t &no_match_count, const idx_t original_count);
+
 template <class OP, bool NO_MATCH_SEL>
-static void TemplatedMatchNested(Vector &col, Vector &rows, SelectionVector &sel, idx_t &count, const RowLayout &layout,
-                                 const idx_t col_no, SelectionVector *no_match, idx_t &no_match_count) {
+static void TemplatedMatchStruct(Vector &vec, UnifiedVectorFormat &col, const TupleDataLayout &layout, Vector &rows,
+                                 SelectionVector &sel, idx_t &count, const idx_t col_no, SelectionVector *no_match,
+                                 idx_t &no_match_count, const idx_t original_count) {
+	// Precompute row_mask indexes
+	idx_t entry_idx;
+	idx_t idx_in_entry;
+	ValidityBytes::GetEntryIndex(col_no, entry_idx, idx_in_entry);
+
+	// Work our way through the validity of the whole struct
+	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
+	idx_t match_count = 0;
+	if (!col.validity.AllValid()) {
+		for (idx_t i = 0; i < count; i++) {
+			auto idx = sel.get_index(i);
+
+			auto row = ptrs[idx];
+			ValidityBytes row_mask(row);
+			auto isnull = !row_mask.RowIsValid(row_mask.GetValidityEntry(entry_idx), idx_in_entry);
+
+			auto col_idx = col.sel->get_index(idx);
+			if (!col.validity.RowIsValid(col_idx)) {
+				if (isnull) {
+					// match: move to next value to compare
+					sel.set_index(match_count++, idx);
+				} else {
+					if (NO_MATCH_SEL) {
+						no_match->set_index(no_match_count++, idx);
+					}
+				}
+			} else {
+				if (!isnull) {
+					sel.set_index(match_count++, idx);
+				} else {
+					if (NO_MATCH_SEL) {
+						no_match->set_index(no_match_count++, idx);
+					}
+				}
+			}
+		}
+	} else {
+		for (idx_t i = 0; i < count; i++) {
+			auto idx = sel.get_index(i);
+
+			auto row = ptrs[idx];
+			ValidityBytes row_mask(row);
+			auto isnull = !row_mask.RowIsValid(row_mask.GetValidityEntry(entry_idx), idx_in_entry);
+
+			if (!isnull) {
+				sel.set_index(match_count++, idx);
+			} else {
+				if (NO_MATCH_SEL) {
+					no_match->set_index(no_match_count++, idx);
+				}
+			}
+		}
+	}
+	count = match_count;
+
+	// Now we construct row pointers to the structs
+	Vector struct_rows(LogicalTypeId::POINTER);
+	auto struct_ptrs = FlatVector::GetData<data_ptr_t>(struct_rows);
+
+	const auto col_offset = layout.GetOffsets()[col_no];
+	for (idx_t i = 0; i < count; i++) {
+		auto idx = sel.get_index(i);
+		auto row = ptrs[idx];
+		struct_ptrs[idx] = row + col_offset;
+	}
+
+	// Get the struct layout, child columns, then recurse
+	const auto &struct_layout = layout.GetStructLayout(col_no);
+	auto &struct_entries = StructVector::GetEntries(vec);
+	D_ASSERT(struct_layout.ColumnCount() == struct_entries.size());
+	for (idx_t struct_col_no = 0; struct_col_no < struct_layout.ColumnCount(); struct_col_no++) {
+		auto &struct_vec = *struct_entries[struct_col_no];
+		UnifiedVectorFormat struct_col;
+		struct_vec.ToUnifiedFormat(original_count, struct_col);
+		TemplatedMatchOp<OP, NO_MATCH_SEL>(struct_vec, struct_col, struct_layout, struct_rows, sel, count,
+		                                   struct_col_no, no_match, no_match_count, original_count);
+	}
+}
+
+template <class OP, bool NO_MATCH_SEL>
+static void TemplatedMatchList(Vector &col, Vector &rows, SelectionVector &sel, idx_t &count,
+                               const TupleDataLayout &layout, const idx_t col_no, SelectionVector *no_match,
+                               idx_t &no_match_count) {
 	// Gather a dense Vector containing the column values being matched
 	Vector key(col.GetType());
-	RowOperations::Gather(rows, sel, key, *FlatVector::IncrementalSelectionVector(), count, layout, col_no);
+	const auto gather_function = TupleDataCollection::GetGatherFunction(col.GetType());
+	gather_function.function(layout, rows, col_no, sel, count, key, *FlatVector::IncrementalSelectionVector(), key,
+	                         gather_function.child_functions);
 
 	// Densify the input column
 	Vector sliced(col, sel, count);
@@ -139,9 +231,9 @@ static void TemplatedMatchNested(Vector &col, Vector &rows, SelectionVector &sel
 }
 
 template <class OP, bool NO_MATCH_SEL>
-static void TemplatedMatchOp(Vector &vec, UnifiedVectorFormat &col, const RowLayout &layout, Vector &rows,
+static void TemplatedMatchOp(Vector &vec, UnifiedVectorFormat &col, const TupleDataLayout &layout, Vector &rows,
                              SelectionVector &sel, idx_t &count, idx_t col_no, SelectionVector *no_match,
-                             idx_t &no_match_count) {
+                             idx_t &no_match_count, const idx_t original_count) {
 	if (count == 0) {
 		return;
 	}
@@ -200,9 +292,12 @@ static void TemplatedMatchOp(Vector &vec, UnifiedVectorFormat &col, const RowLay
 		TemplatedMatchType<string_t, OP, NO_MATCH_SEL>(col, rows, sel, count, col_offset, col_no, no_match,
 		                                               no_match_count);
 		break;
-	case PhysicalType::LIST:
 	case PhysicalType::STRUCT:
-		TemplatedMatchNested<OP, NO_MATCH_SEL>(vec, rows, sel, count, layout, col_no, no_match, no_match_count);
+		TemplatedMatchStruct<OP, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match, no_match_count,
+		                                       original_count);
+		break;
+	case PhysicalType::LIST:
+		TemplatedMatchList<OP, NO_MATCH_SEL>(vec, rows, sel, count, layout, col_no, no_match, no_match_count);
 		break;
 	default:
 		throw InternalException("Unsupported column type for RowOperations::Match");
@@ -210,9 +305,9 @@ static void TemplatedMatchOp(Vector &vec, UnifiedVectorFormat &col, const RowLay
 }
 
 template <bool NO_MATCH_SEL>
-static void TemplatedMatch(DataChunk &columns, UnifiedVectorFormat col_data[], const RowLayout &layout, Vector &rows,
-                           const Predicates &predicates, SelectionVector &sel, idx_t &count, SelectionVector *no_match,
-                           idx_t &no_match_count) {
+static void TemplatedMatch(DataChunk &columns, UnifiedVectorFormat col_data[], const TupleDataLayout &layout,
+                           Vector &rows, const Predicates &predicates, SelectionVector &sel, idx_t &count,
+                           SelectionVector *no_match, idx_t &no_match_count) {
 	for (idx_t col_no = 0; col_no < predicates.size(); ++col_no) {
 		auto &vec = columns.data[col_no];
 		auto &col = col_data[col_no];
@@ -220,28 +315,28 @@ static void TemplatedMatch(DataChunk &columns, UnifiedVectorFormat col_data[], c
 		case ExpressionType::COMPARE_EQUAL:
 		case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
 		case ExpressionType::COMPARE_DISTINCT_FROM:
-			TemplatedMatchOp<Equals, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
-			                                       no_match_count);
+			TemplatedMatchOp<Equals, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match, no_match_count,
+			                                       count);
 			break;
 		case ExpressionType::COMPARE_NOTEQUAL:
 			TemplatedMatchOp<NotEquals, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
-			                                          no_match_count);
+			                                          no_match_count, count);
 			break;
 		case ExpressionType::COMPARE_GREATERTHAN:
 			TemplatedMatchOp<GreaterThan, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
-			                                            no_match_count);
+			                                            no_match_count, count);
 			break;
 		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
 			TemplatedMatchOp<GreaterThanEquals, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
-			                                                  no_match_count);
+			                                                  no_match_count, count);
 			break;
 		case ExpressionType::COMPARE_LESSTHAN:
 			TemplatedMatchOp<LessThan, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
-			                                         no_match_count);
+			                                         no_match_count, count);
 			break;
 		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
 			TemplatedMatchOp<LessThanEquals, NO_MATCH_SEL>(vec, col, layout, rows, sel, count, col_no, no_match,
-			                                               no_match_count);
+			                                               no_match_count, count);
 			break;
 		default:
 			throw InternalException("Unsupported comparison type for RowOperations::Match");
@@ -249,9 +344,9 @@ static void TemplatedMatch(DataChunk &columns, UnifiedVectorFormat col_data[], c
 	}
 }
 
-idx_t RowOperations::Match(DataChunk &columns, UnifiedVectorFormat col_data[], const RowLayout &layout, Vector &rows,
-                           const Predicates &predicates, SelectionVector &sel, idx_t count, SelectionVector *no_match,
-                           idx_t &no_match_count) {
+idx_t RowOperations::Match(DataChunk &columns, UnifiedVectorFormat col_data[], const TupleDataLayout &layout,
+                           Vector &rows, const Predicates &predicates, SelectionVector &sel, idx_t count,
+                           SelectionVector *no_match, idx_t &no_match_count) {
 	if (no_match) {
 		TemplatedMatch<true>(columns, col_data, layout, rows, predicates, sel, count, no_match, no_match_count);
 	} else {

package/src/duckdb/src/common/row_operations/row_scatter.cpp

@@ -8,8 +8,8 @@
 #include "duckdb/common/helper.hpp"
 #include "duckdb/common/row_operations/row_operations.hpp"
 #include "duckdb/common/types/null_value.hpp"
-#include "duckdb/common/types/row_data_collection.hpp"
-#include "duckdb/common/types/row_layout.hpp"
+#include "duckdb/common/types/row/row_data_collection.hpp"
+#include "duckdb/common/types/row/row_layout.hpp"
 #include "duckdb/common/types/selection_vector.hpp"
 #include "duckdb/common/types/vector.hpp"
 
@@ -67,6 +67,8 @@ static void ScatterStringVector(UnifiedVectorFormat &col, Vector &rows, data_ptr
 	auto string_data = (string_t *)col.data;
 	auto ptrs = FlatVector::GetData<data_ptr_t>(rows);
 
+	// Write out zero length to avoid swizzling problems.
+	const string_t null(nullptr, 0);
 	for (idx_t i = 0; i < count; i++) {
 		auto idx = sel.get_index(i);
 		auto col_idx = col.sel->get_index(idx);
@@ -74,13 +76,13 @@ static void ScatterStringVector(UnifiedVectorFormat &col, Vector &rows, data_ptr
 		if (!col.validity.RowIsValid(col_idx)) {
 			ValidityBytes col_mask(row);
 			col_mask.SetInvalidUnsafe(col_no);
-			Store<string_t>(NullValue<string_t>(), row + col_offset);
+			Store<string_t>(null, row + col_offset);
 		} else if (string_data[col_idx].IsInlined()) {
 			Store<string_t>(string_data[col_idx], row + col_offset);
 		} else {
 			const auto &str = string_data[col_idx];
 			string_t inserted((const char *)str_locations[i], str.GetSize());
-			memcpy(inserted.GetDataWriteable(), str.GetDataUnsafe(), str.GetSize());
+			memcpy(inserted.GetDataWriteable(), str.GetData(), str.GetSize());
 			str_locations[i] += str.GetSize();
 			inserted.Finalize();
 			Store<string_t>(inserted, row + col_offset);
@@ -152,7 +154,7 @@ void RowOperations::Scatter(DataChunk &columns, UnifiedVectorFormat col_data[],
 		}
 
 		// Build out the buffer space
-		string_heap.Build(count, data_locations, entry_sizes);
+		handles = string_heap.Build(count, data_locations, entry_sizes);
 
 		// Serialize information that is needed for swizzling if the computation goes out-of-core
 		const idx_t heap_pointer_offset = layout.GetHeapOffset();

package/src/duckdb/src/common/serializer/binary_deserializer.cpp

@@ -0,0 +1,143 @@
+#include "duckdb/common/serializer/binary_deserializer.hpp"
+
+namespace duckdb {
+
+void BinaryDeserializer::SetTag(const char *tag) {
+	current_tag = tag;
+	stack.back().read_field_count++;
+}
+
+//===--------------------------------------------------------------------===//
+// Nested Types Hooks
+//===--------------------------------------------------------------------===//
+void BinaryDeserializer::OnObjectBegin() {
+	auto expected_field_count = ReadPrimitive<uint32_t>();
+	auto expected_size = ReadPrimitive<uint64_t>();
+	D_ASSERT(expected_field_count > 0);
+	D_ASSERT(expected_size > 0);
+
+	stack.emplace_back(expected_field_count, expected_size);
+}
+
+void BinaryDeserializer::OnObjectEnd() {
+	auto &frame = stack.back();
+	if (frame.read_field_count < frame.expected_field_count) {
+		throw SerializationException("Not all fields were read. This file might have been written with a newer version "
+		                             "of DuckDB and is incompatible with this version of DuckDB.");
+	}
+	stack.pop_back();
+}
+
+idx_t BinaryDeserializer::OnListBegin() {
+	return ReadPrimitive<idx_t>();
+}
+
+void BinaryDeserializer::OnListEnd() {
+}
+
+// Deserialize maps as [ { key: ..., value: ... } ]
+idx_t BinaryDeserializer::OnMapBegin() {
+	return ReadPrimitive<idx_t>();
+}
+
+void BinaryDeserializer::OnMapEntryBegin() {
+}
+
+void BinaryDeserializer::OnMapKeyBegin() {
+}
+
+void BinaryDeserializer::OnMapValueBegin() {
+}
+
+void BinaryDeserializer::OnMapEntryEnd() {
+}
+
+void BinaryDeserializer::OnMapEnd() {
+}
+
+void BinaryDeserializer::OnPairBegin() {
+}
+
+void BinaryDeserializer::OnPairKeyBegin() {
+}
+
+void BinaryDeserializer::OnPairValueBegin() {
+}
+
+void BinaryDeserializer::OnPairEnd() {
+}
+
+bool BinaryDeserializer::OnOptionalBegin() {
+	return ReadPrimitive<bool>();
+}
+
+//===--------------------------------------------------------------------===//
+// Primitive Types
+//===--------------------------------------------------------------------===//
+bool BinaryDeserializer::ReadBool() {
+	return ReadPrimitive<bool>();
+}
+
+int8_t BinaryDeserializer::ReadSignedInt8() {
+	return ReadPrimitive<int8_t>();
+}
+
+uint8_t BinaryDeserializer::ReadUnsignedInt8() {
+	return ReadPrimitive<uint8_t>();
+}
+
+int16_t BinaryDeserializer::ReadSignedInt16() {
+	return ReadPrimitive<int16_t>();
+}
+
+uint16_t BinaryDeserializer::ReadUnsignedInt16() {
+	return ReadPrimitive<uint16_t>();
+}
+
+int32_t BinaryDeserializer::ReadSignedInt32() {
+	return ReadPrimitive<int32_t>();
+}
+
+uint32_t BinaryDeserializer::ReadUnsignedInt32() {
+	return ReadPrimitive<uint32_t>();
+}
+
+int64_t BinaryDeserializer::ReadSignedInt64() {
+	return ReadPrimitive<int64_t>();
+}
+
+uint64_t BinaryDeserializer::ReadUnsignedInt64() {
+	return ReadPrimitive<uint64_t>();
+}
+
+float BinaryDeserializer::ReadFloat() {
+	return ReadPrimitive<float>();
+}
+
+double BinaryDeserializer::ReadDouble() {
+	return ReadPrimitive<double>();
+}
+
+string BinaryDeserializer::ReadString() {
+	uint32_t size = ReadPrimitive<uint32_t>();
+	if (size == 0) {
+		return string();
+	}
+	auto buffer = unique_ptr<data_t[]>(new data_t[size]);
+	ReadData(buffer.get(), size);
+	return string((char *)buffer.get(), size);
+}
+
+interval_t BinaryDeserializer::ReadInterval() {
+	return ReadPrimitive<interval_t>();
+}
+
+hugeint_t BinaryDeserializer::ReadHugeInt() {
+	return ReadPrimitive<hugeint_t>();
+}
+
+void BinaryDeserializer::ReadDataPtr(data_ptr_t &ptr, idx_t count) {
+	ReadData(ptr, count);
+}
+
+} // namespace duckdb

package/src/duckdb/src/common/serializer/binary_serializer.cpp

@@ -0,0 +1,160 @@
+#include "duckdb/common/serializer/binary_serializer.hpp"
+
+namespace duckdb {
+
+void BinarySerializer::SetTag(const char *tag) {
+	current_tag = tag;
+
+	// Increment the number of fields
+	stack.back().field_count++;
+}
+
+//===--------------------------------------------------------------------===//
+// Nested types
+//===--------------------------------------------------------------------===//
+void BinarySerializer::OnOptionalBegin(bool present) {
+	Write(present);
+}
+
+void BinarySerializer::OnListBegin(idx_t count) {
+	Write(count);
+}
+
+void BinarySerializer::OnListEnd(idx_t count) {
+}
+
+// Serialize maps as arrays of objects with "key" and "value" properties.
+void BinarySerializer::OnMapBegin(idx_t count) {
+	Write(count);
+}
+
+void BinarySerializer::OnMapEntryBegin() {
+}
+
+void BinarySerializer::OnMapKeyBegin() {
+}
+
+void BinarySerializer::OnMapValueBegin() {
+}
+
+void BinarySerializer::OnMapEntryEnd() {
+}
+
+void BinarySerializer::OnMapEnd(idx_t count) {
+}
+
+void BinarySerializer::OnObjectBegin() {
+	stack.push_back(State({0, 0, data.size()}));
+	Write<uint32_t>(0); // Placeholder for the field count
+	Write<uint64_t>(0); // Placeholder for the size
+}
+
+void BinarySerializer::OnObjectEnd() {
+	auto &frame = stack.back();
+	// Patch the field count and size
+	auto message_start = &data[frame.offset];
+	Store<uint32_t>(frame.field_count, message_start);
+	Store<uint64_t>(frame.size, message_start + sizeof(uint32_t));
+	stack.pop_back();
+}
+
+void BinarySerializer::OnPairBegin() {
+}
+
+void BinarySerializer::OnPairKeyBegin() {
+}
+
+void BinarySerializer::OnPairValueBegin() {
+}
+
+void BinarySerializer::OnPairEnd() {
+}
+
+//===--------------------------------------------------------------------===//
+// Primitive types
+//===--------------------------------------------------------------------===//
+void BinarySerializer::WriteNull() {
+	// This should never be called, optional writes should be handled by OnOptionalBegin
+}
+
+void BinarySerializer::WriteValue(uint8_t value) {
+	Write(value);
+}
+
+void BinarySerializer::WriteValue(int8_t value) {
+	Write(value);
+}
+
+void BinarySerializer::WriteValue(uint16_t value) {
+	Write(value);
+}
+
+void BinarySerializer::WriteValue(int16_t value) {
+	Write(value);
+}
+
+void BinarySerializer::WriteValue(uint32_t value) {
+	Write(value);
+}
+
+void BinarySerializer::WriteValue(int32_t value) {
+	Write(value);
+}
+
+void BinarySerializer::WriteValue(uint64_t value) {
+	Write(value);
+}
+
+void BinarySerializer::WriteValue(int64_t value) {
+	Write(value);
+}
+
+void BinarySerializer::WriteValue(hugeint_t value) {
+	Write(value);
+}
+
+void BinarySerializer::WriteValue(float value) {
+	Write(value);
+}
+
+void BinarySerializer::WriteValue(double value) {
+	Write(value);
+}
+
+void BinarySerializer::WriteValue(interval_t value) {
+	Write(value);
+}
+
+void BinarySerializer::WriteValue(const string &value) {
+	auto len = value.length();
+	Write<uint32_t>((uint32_t)len);
+	if (len > 0) {
+		WriteData((const_data_ptr_t)value.c_str(), len);
+	}
+}
+
+void BinarySerializer::WriteValue(const string_t value) {
+	auto len = value.GetSize();
+	Write<uint32_t>((uint32_t)len);
+	if (len > 0) {
+		WriteData((const_data_ptr_t)value.GetDataUnsafe(), len);
+	}
+}
+
+void BinarySerializer::WriteValue(const char *value) {
+	auto len = strlen(value);
+	Write<uint32_t>((uint32_t)len);
+	if (len > 0) {
+		WriteData((const_data_ptr_t)value, len);
+	}
+}
+
+void BinarySerializer::WriteValue(bool value) {
+	Write(value);
+}
+
+void BinarySerializer::WriteDataPtr(const_data_ptr_t ptr, idx_t count) {
+	WriteData(ptr, count);
+}
+
+} // namespace duckdb

package/src/duckdb/src/common/serializer/buffered_deserializer.cpp

@@ -20,4 +20,8 @@ void BufferedDeserializer::ReadData(data_ptr_t buffer, idx_t read_size) {
 	ptr += read_size;
 }
 
+ClientContext &BufferedContextDeserializer::GetContext() {
+	return context;
+}
+
 } // namespace duckdb

package/src/duckdb/src/common/serializer/buffered_file_reader.cpp

@@ -7,9 +7,11 @@
 
 namespace duckdb {
 
-BufferedFileReader::BufferedFileReader(FileSystem &fs, const char *path, FileLockType lock_type, FileOpener *opener)
-    : fs(fs), data(unique_ptr<data_t[]>(new data_t[FILE_BUFFER_SIZE])), offset(0), read_data(0), total_read(0) {
-	handle = fs.OpenFile(path, FileFlags::FILE_FLAGS_READ, lock_type, FileSystem::DEFAULT_COMPRESSION, opener);
+BufferedFileReader::BufferedFileReader(FileSystem &fs, const char *path, optional_ptr<ClientContext> context,
+                                       FileLockType lock_type, optional_ptr<FileOpener> opener)
+    : fs(fs), data(unique_ptr<data_t[]>(new data_t[FILE_BUFFER_SIZE])), offset(0), read_data(0), total_read(0),
+      context(context) {
+	handle = fs.OpenFile(path, FileFlags::FILE_FLAGS_READ, lock_type, FileSystem::DEFAULT_COMPRESSION, opener.get());
 	file_size = fs.GetFileSize(*handle);
 }
 
@@ -54,4 +56,20 @@ uint64_t BufferedFileReader::CurrentOffset() {
 	return total_read + offset;
 }
 
+ClientContext &BufferedFileReader::GetContext() {
+	if (!context) {
+		throw InternalException("Trying to acquire a client context that does not exist");
+	}
+	return *context;
+}
+
+optional_ptr<Catalog> BufferedFileReader::GetCatalog() {
+	return catalog;
+}
+
+void BufferedFileReader::SetCatalog(Catalog &catalog_p) {
+	D_ASSERT(!catalog);
+	this->catalog = &catalog_p;
+}
+
 } // namespace duckdb

package/src/duckdb/src/common/sort/comparators.cpp

@@ -163,17 +163,26 @@ int Comparators::CompareStringAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right
 	if (!valid) {
 		return 0;
 	}
-	// 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);
+	auto memcmp_res = memcmp((const char *)left_ptr, (const char *)right_ptr,
+	                         std::min<uint32_t>(left_string_size, 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);
+
+	if (memcmp_res != 0) {
+		return memcmp_res;
+	}
+	if (left_string_size == right_string_size) {
+		return 0;
+	}
+	if (left_string_size < right_string_size) {
+		return -1;
+	}
+	return 1;
 }
 
 int Comparators::CompareStructAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr,