duckdb 0.8.2-dev4142.0 → 0.8.2-dev4314.0

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

@@ -0,0 +1,61 @@
+#include "duckdb/common/serializer/memory_stream.hpp"
+
+namespace duckdb {
+
+MemoryStream::MemoryStream(idx_t capacity)
+    : position(0), capacity(capacity), owns_data(true), data(static_cast<data_ptr_t>(malloc(capacity))) {
+}
+
+MemoryStream::MemoryStream(data_ptr_t buffer, idx_t capacity)
+    : position(0), capacity(capacity), owns_data(false), data(buffer) {
+}
+
+MemoryStream::~MemoryStream() {
+	if (owns_data) {
+		free(data);
+	}
+}
+
+void MemoryStream::WriteData(const_data_ptr_t source, idx_t write_size) {
+	while (position + write_size > capacity) {
+		if (owns_data) {
+			capacity *= 2;
+			data = static_cast<data_ptr_t>(realloc(data, capacity));
+		} else {
+			throw SerializationException("Failed to serialize: not enough space in buffer to fulfill write request");
+		}
+	}
+
+	memcpy(data + position, source, write_size);
+	position += write_size;
+}
+
+void MemoryStream::ReadData(data_ptr_t destination, idx_t read_size) {
+	if (position + read_size > capacity) {
+		throw SerializationException("Failed to deserialize: not enough data in buffer to fulfill read request");
+	}
+	memcpy(destination, data + position, read_size);
+	position += read_size;
+}
+
+void MemoryStream::Rewind() {
+	position = 0;
+}
+
+void MemoryStream::Release() {
+	owns_data = false;
+}
+
+data_ptr_t MemoryStream::GetData() const {
+	return data;
+}
+
+idx_t MemoryStream::GetPosition() const {
+	return position;
+}
+
+idx_t MemoryStream::GetCapacity() const {
+	return capacity;
+}
+
+} // namespace duckdb

package/src/duckdb/src/common/serializer/{format_serializer.cpp → serializer.cpp}

@@ -1,9 +1,9 @@
-#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
 
 namespace duckdb {
 
 template <>
-void FormatSerializer::WriteValue(const vector<bool> &vec) {
+void Serializer::WriteValue(const vector<bool> &vec) {
 	auto count = vec.size();
 	OnListBegin(count);
 	for (auto item : vec) {

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

@@ -100,11 +100,30 @@ PartitionGlobalSinkState::PartitionGlobalSinkState(ClientContext &context,
 	}
 
 	if (!orders.empty()) {
-		auto types = payload_types;
-		types.push_back(LogicalType::HASH);
-		grouping_types.Initialize(types);
+		if (partitions.empty()) {
+			//	Sort early into a dedicated hash group if we only sort.
+			grouping_types.Initialize(payload_types);
+			auto new_group =
+			    make_uniq<PartitionGlobalHashGroup>(buffer_manager, partitions, orders, payload_types, external);
+			hash_groups.emplace_back(std::move(new_group));
+		} else {
+			auto types = payload_types;
+			types.push_back(LogicalType::HASH);
+			grouping_types.Initialize(types);
+			ResizeGroupingData(estimated_cardinality);
+		}
+	}
+}
 
-		ResizeGroupingData(estimated_cardinality);
+bool PartitionGlobalSinkState::HasMergeTasks() const {
+	if (grouping_data) {
+		auto &groups = grouping_data->GetPartitions();
+		return !groups.empty();
+	} else if (!hash_groups.empty()) {
+		D_ASSERT(hash_groups.size() == 1);
+		return hash_groups[0]->count > 0;
+	} else {
+		return false;
 	}
 }
 
@@ -206,6 +225,12 @@ PartitionLocalMergeState::PartitionLocalMergeState(PartitionGlobalSinkState &gst
 }
 
 void PartitionLocalMergeState::Scan() {
+	if (!merge_state->group_data) {
+		//	OVER(ORDER BY...)
+		//	Already sorted
+		return;
+	}
+
 	auto &group_data = *merge_state->group_data;
 	auto &hash_group = *merge_state->hash_group;
 	auto &chunk_state = merge_state->chunk_state;
@@ -243,13 +268,26 @@ PartitionLocalSinkState::PartitionLocalSinkState(ClientContext &context, Partiti
 	sort_cols = gstate.orders.size() + group_types.size();
 
 	if (sort_cols) {
+		auto payload_types = gstate.payload_types;
 		if (!group_types.empty()) {
 			// OVER(PARTITION BY...)
 			group_chunk.Initialize(allocator, group_types);
+			payload_types.emplace_back(LogicalType::HASH);
+		} else {
+			// OVER(ORDER BY...)
+			for (idx_t ord_idx = 0; ord_idx < gstate.orders.size(); ord_idx++) {
+				auto &pexpr = *gstate.orders[ord_idx].expression.get();
+				group_types.push_back(pexpr.return_type);
+				executor.AddExpression(pexpr);
+			}
+			group_chunk.Initialize(allocator, group_types);
+
+			//	Single partition
+			auto &global_sort = *gstate.hash_groups[0]->global_sort;
+			local_sort = make_uniq<LocalSortState>();
+			local_sort->Initialize(global_sort, global_sort.buffer_manager);
 		}
 		// OVER(...)
-		auto payload_types = gstate.payload_types;
-		payload_types.emplace_back(LogicalType::HASH);
 		payload_chunk.Initialize(allocator, payload_types);
 	} else {
 		// OVER()
@@ -259,20 +297,14 @@ PartitionLocalSinkState::PartitionLocalSinkState(ClientContext &context, Partiti
 
 void PartitionLocalSinkState::Hash(DataChunk &input_chunk, Vector &hash_vector) {
 	const auto count = input_chunk.size();
-	if (group_chunk.ColumnCount() > 0) {
-		// OVER(PARTITION BY...) (hash grouping)
-		group_chunk.Reset();
-		executor.Execute(input_chunk, group_chunk);
-		VectorOperations::Hash(group_chunk.data[0], hash_vector, count);
-		for (idx_t prt_idx = 1; prt_idx < group_chunk.ColumnCount(); ++prt_idx) {
-			VectorOperations::CombineHash(hash_vector, group_chunk.data[prt_idx], count);
-		}
-	} else {
-		// OVER(...) (sorting)
-		// Single partition => single hash value
-		hash_vector.SetVectorType(VectorType::CONSTANT_VECTOR);
-		auto hashes = ConstantVector::GetData<hash_t>(hash_vector);
-		hashes[0] = 0;
+	D_ASSERT(group_chunk.ColumnCount() > 0);
+
+	// OVER(PARTITION BY...) (hash grouping)
+	group_chunk.Reset();
+	executor.Execute(input_chunk, group_chunk);
+	VectorOperations::Hash(group_chunk.data[0], hash_vector, count);
+	for (idx_t prt_idx = 1; prt_idx < group_chunk.ColumnCount(); ++prt_idx) {
+		VectorOperations::CombineHash(hash_vector, group_chunk.data[prt_idx], count);
 	}
 }
 
@@ -306,6 +338,22 @@ void PartitionLocalSinkState::Sink(DataChunk &input_chunk) {
 		return;
 	}
 
+	if (local_sort) {
+		//	OVER(ORDER BY...)
+		group_chunk.Reset();
+		executor.Execute(input_chunk, group_chunk);
+		local_sort->SinkChunk(group_chunk, input_chunk);
+
+		auto &hash_group = *gstate.hash_groups[0];
+		hash_group.count += input_chunk.size();
+
+		if (local_sort->SizeInBytes() > gstate.memory_per_thread) {
+			auto &global_sort = *hash_group.global_sort;
+			local_sort->Sort(global_sort, true);
+		}
+		return;
+	}
+
 	// OVER(...)
 	payload_chunk.Reset();
 	auto &hash_vector = payload_chunk.data.back();
@@ -338,6 +386,15 @@ void PartitionLocalSinkState::Combine() {
 		return;
 	}
 
+	if (local_sort) {
+		//	OVER(ORDER BY...)
+		auto &hash_group = *gstate.hash_groups[0];
+		auto &global_sort = *hash_group.global_sort;
+		global_sort.AddLocalState(*local_sort);
+		local_sort.reset();
+		return;
+	}
+
 	// OVER(...)
 	gstate.CombineLocalPartition(local_partition, local_append);
 }
@@ -365,6 +422,19 @@ PartitionGlobalMergeState::PartitionGlobalMergeState(PartitionGlobalSinkState &s
 	group_data->InitializeScan(chunk_state, column_ids);
 }
 
+PartitionGlobalMergeState::PartitionGlobalMergeState(PartitionGlobalSinkState &sink)
+    : sink(sink), memory_per_thread(sink.memory_per_thread),
+      num_threads(TaskScheduler::GetScheduler(sink.context).NumberOfThreads()), stage(PartitionSortStage::INIT),
+      total_tasks(0), tasks_assigned(0), tasks_completed(0) {
+
+	const hash_t hash_bin = 0;
+	const size_t group_idx = 0;
+	hash_group = sink.hash_groups[group_idx].get();
+	global_sort = sink.hash_groups[group_idx]->global_sort.get();
+
+	sink.bin_groups[hash_bin] = group_idx;
+}
+
 void PartitionLocalMergeState::Prepare() {
 	merge_state->group_data.reset();
 
@@ -390,7 +460,7 @@ void PartitionLocalMergeState::ExecuteTask() {
 		Merge();
 		break;
 	default:
-		throw InternalException("Unexpected PartitionGlobalMergeState in ExecuteTask!");
+		throw InternalException("Unexpected PartitionSortStage in ExecuteTask!");
 	}
 
 	merge_state->CompleteTask();
@@ -471,15 +541,23 @@ bool PartitionGlobalMergeState::TryPrepareNextStage() {
 
 PartitionGlobalMergeStates::PartitionGlobalMergeStates(PartitionGlobalSinkState &sink) {
 	// Schedule all the sorts for maximum thread utilisation
-	auto &partitions = sink.grouping_data->GetPartitions();
-	sink.bin_groups.resize(partitions.size(), partitions.size());
-	for (hash_t hash_bin = 0; hash_bin < partitions.size(); ++hash_bin) {
-		auto &group_data = partitions[hash_bin];
-		// Prepare for merge sort phase
-		if (group_data->Count()) {
-			auto state = make_uniq<PartitionGlobalMergeState>(sink, std::move(group_data), hash_bin);
-			states.emplace_back(std::move(state));
+	if (sink.grouping_data) {
+		auto &partitions = sink.grouping_data->GetPartitions();
+		sink.bin_groups.resize(partitions.size(), partitions.size());
+		for (hash_t hash_bin = 0; hash_bin < partitions.size(); ++hash_bin) {
+			auto &group_data = partitions[hash_bin];
+			// Prepare for merge sort phase
+			if (group_data->Count()) {
+				auto state = make_uniq<PartitionGlobalMergeState>(sink, std::move(group_data), hash_bin);
+				states.emplace_back(std::move(state));
+			}
 		}
+	} else {
+		//	OVER(ORDER BY...)
+		//	Already sunk into the single global sort, so set up single merge with no data
+		sink.bin_groups.resize(1, 1);
+		auto state = make_uniq<PartitionGlobalMergeState>(sink);
+		states.emplace_back(std::move(state));
 	}
 }
 

package/src/duckdb/src/common/types/column/column_data_collection.cpp

@@ -6,8 +6,8 @@
 #include "duckdb/common/types/value_map.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -1059,7 +1059,7 @@ const vector<unique_ptr<ColumnDataCollectionSegment>> &ColumnDataCollection::Get
 	return segments;
 }
 
-void ColumnDataCollection::FormatSerialize(FormatSerializer &serializer) const {
+void ColumnDataCollection::Serialize(Serializer &serializer) const {
 	vector<vector<Value>> values;
 	values.resize(ColumnCount());
 	for (auto &chunk : Chunks()) {
@@ -1073,7 +1073,7 @@ void ColumnDataCollection::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(101, "values", values);
 }
 
-unique_ptr<ColumnDataCollection> ColumnDataCollection::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<ColumnDataCollection> ColumnDataCollection::Deserialize(Deserializer &deserializer) {
 	auto types = deserializer.ReadProperty<vector<LogicalType>>(100, "types");
 	auto values = deserializer.ReadProperty<vector<vector<Value>>>(101, "values");
 

package/src/duckdb/src/common/types/data_chunk.cpp

@@ -4,9 +4,8 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/helper.hpp"
 #include "duckdb/common/printer.hpp"
-#include "duckdb/common/serializer.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 #include "duckdb/common/types/interval.hpp"
 #include "duckdb/common/types/sel_cache.hpp"
 #include "duckdb/common/types/vector_cache.hpp"
@@ -231,38 +230,7 @@ string DataChunk::ToString() const {
 	return retval;
 }
 
-void DataChunk::Serialize(Serializer &serializer) {
-	// write the count
-	serializer.Write<sel_t>(size());
-	serializer.Write<idx_t>(ColumnCount());
-	for (idx_t col_idx = 0; col_idx < ColumnCount(); col_idx++) {
-		// write the types
-		data[col_idx].GetType().Serialize(serializer);
-	}
-	// write the data
-	for (idx_t col_idx = 0; col_idx < ColumnCount(); col_idx++) {
-		data[col_idx].Serialize(size(), serializer);
-	}
-}
-
-void DataChunk::Deserialize(Deserializer &source) {
-	auto rows = source.Read<sel_t>();
-	idx_t column_count = source.Read<idx_t>();
-
-	vector<LogicalType> types;
-	for (idx_t i = 0; i < column_count; i++) {
-		types.push_back(LogicalType::Deserialize(source));
-	}
-	Initialize(Allocator::DefaultAllocator(), types);
-	// now load the column data
-	SetCardinality(rows);
-	for (idx_t i = 0; i < column_count; i++) {
-		data[i].Deserialize(rows, source);
-	}
-	Verify();
-}
-
-void DataChunk::FormatSerialize(FormatSerializer &serializer) const {
+void DataChunk::Serialize(Serializer &serializer) const {
 	// write the count
 	auto row_count = size();
 	serializer.WriteProperty<sel_t>(100, "rows", row_count);
@@ -270,26 +238,26 @@ void DataChunk::FormatSerialize(FormatSerializer &serializer) const {
 
 	// Write the types
 	serializer.WriteList(101, "types", column_count,
-	                     [&](FormatSerializer::List &list, idx_t i) { list.WriteElement(data[i].GetType()); });
+	                     [&](Serializer::List &list, idx_t i) { list.WriteElement(data[i].GetType()); });
 
 	// Write the data
-	serializer.WriteList(102, "columns", column_count, [&](FormatSerializer::List &list, idx_t i) {
-		list.WriteObject([&](FormatSerializer &object) {
+	serializer.WriteList(102, "columns", column_count, [&](Serializer::List &list, idx_t i) {
+		list.WriteObject([&](Serializer &object) {
 			// Reference the vector to avoid potentially mutating it during serialization
 			Vector serialized_vector(data[i].GetType());
 			serialized_vector.Reference(data[i]);
-			serialized_vector.FormatSerialize(object, row_count);
+			serialized_vector.Serialize(object, row_count);
 		});
 	});
 }
 
-void DataChunk::FormatDeserialize(FormatDeserializer &deserializer) {
+void DataChunk::Deserialize(Deserializer &deserializer) {
 	// read the count
 	auto row_count = deserializer.ReadProperty<sel_t>(100, "rows");
 
 	// Read the types
 	vector<LogicalType> types;
-	deserializer.ReadList(101, "types", [&](FormatDeserializer::List &list, idx_t i) {
+	deserializer.ReadList(101, "types", [&](Deserializer::List &list, idx_t i) {
 		auto type = list.ReadElement<LogicalType>();
 		types.push_back(type);
 	});
@@ -299,8 +267,8 @@ void DataChunk::FormatDeserialize(FormatDeserializer &deserializer) {
 	SetCardinality(row_count);
 
 	// Read the data
-	deserializer.ReadList(102, "columns", [&](FormatDeserializer::List &list, idx_t i) {
-		list.ReadObject([&](FormatDeserializer &object) { data[i].FormatDeserialize(object, row_count); });
+	deserializer.ReadList(102, "columns", [&](Deserializer::List &list, idx_t i) {
+		list.ReadObject([&](Deserializer &object) { data[i].Deserialize(object, row_count); });
 	});
 }
 

package/src/duckdb/src/common/types/hyperloglog.cpp

@@ -1,9 +1,8 @@
 #include "duckdb/common/types/hyperloglog.hpp"
 
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 #include "hyperloglog.hpp"
 
@@ -91,30 +90,12 @@ unique_ptr<HyperLogLog> HyperLogLog::Copy() {
 	return result;
 }
 
-void HyperLogLog::Serialize(FieldWriter &writer) const {
-	writer.WriteField<HLLStorageType>(HLLStorageType::UNCOMPRESSED);
-	writer.WriteBlob(GetPtr(), GetSize());
-}
-
-unique_ptr<HyperLogLog> HyperLogLog::Deserialize(FieldReader &reader) {
-	auto result = make_uniq<HyperLogLog>();
-	auto storage_type = reader.ReadRequired<HLLStorageType>();
-	switch (storage_type) {
-	case HLLStorageType::UNCOMPRESSED:
-		reader.ReadBlob(result->GetPtr(), GetSize());
-		break;
-	default:
-		throw SerializationException("Unknown HyperLogLog storage type!");
-	}
-	return result;
-}
-
-void HyperLogLog::FormatSerialize(FormatSerializer &serializer) const {
+void HyperLogLog::Serialize(Serializer &serializer) const {
 	serializer.WriteProperty(100, "type", HLLStorageType::UNCOMPRESSED);
 	serializer.WriteProperty(101, "data", GetPtr(), GetSize());
 }
 
-unique_ptr<HyperLogLog> HyperLogLog::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<HyperLogLog> HyperLogLog::Deserialize(Deserializer &deserializer) {
 	auto result = make_uniq<HyperLogLog>();
 	auto storage_type = deserializer.ReadProperty<HLLStorageType>(100, "type");
 	switch (storage_type) {

package/src/duckdb/src/common/types/interval.cpp

@@ -11,8 +11,8 @@
 #include "duckdb/common/operator/subtract.hpp"
 #include "duckdb/common/string_util.hpp"
 
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/common/types/value.cpp

@@ -10,7 +10,6 @@
 #include "utf8proc_wrapper.hpp"
 #include "duckdb/common/operator/numeric_binary_operators.hpp"
 #include "duckdb/common/printer.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/types/blob.hpp"
 #include "duckdb/common/types/date.hpp"
 #include "duckdb/common/types/decimal.hpp"
@@ -30,8 +29,8 @@
 #include "duckdb/function/cast/cast_function_set.hpp"
 #include "duckdb/main/error_manager.hpp"
 
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 #include <utility>
 #include <cmath>
@@ -1651,131 +1650,7 @@ void Value::Reinterpret(LogicalType new_type) {
 	this->type_ = std::move(new_type);
 }
 
-void Value::Serialize(Serializer &main_serializer) const {
-	FieldWriter writer(main_serializer);
-	writer.WriteSerializable(type_);
-	writer.WriteField<bool>(IsNull());
-	if (!IsNull()) {
-		auto &serializer = writer.GetSerializer();
-		switch (type_.InternalType()) {
-		case PhysicalType::BOOL:
-			serializer.Write<int8_t>(value_.boolean);
-			break;
-		case PhysicalType::INT8:
-			serializer.Write<int8_t>(value_.tinyint);
-			break;
-		case PhysicalType::INT16:
-			serializer.Write<int16_t>(value_.smallint);
-			break;
-		case PhysicalType::INT32:
-			serializer.Write<int32_t>(value_.integer);
-			break;
-		case PhysicalType::INT64:
-			serializer.Write<int64_t>(value_.bigint);
-			break;
-		case PhysicalType::UINT8:
-			serializer.Write<uint8_t>(value_.utinyint);
-			break;
-		case PhysicalType::UINT16:
-			serializer.Write<uint16_t>(value_.usmallint);
-			break;
-		case PhysicalType::UINT32:
-			serializer.Write<uint32_t>(value_.uinteger);
-			break;
-		case PhysicalType::UINT64:
-			serializer.Write<uint64_t>(value_.ubigint);
-			break;
-		case PhysicalType::INT128:
-			serializer.Write<hugeint_t>(value_.hugeint);
-			break;
-		case PhysicalType::FLOAT:
-			serializer.Write<float>(value_.float_);
-			break;
-		case PhysicalType::DOUBLE:
-			serializer.Write<double>(value_.double_);
-			break;
-		case PhysicalType::INTERVAL:
-			serializer.Write<interval_t>(value_.interval);
-			break;
-		case PhysicalType::VARCHAR:
-			serializer.WriteString(StringValue::Get(*this));
-			break;
-		default: {
-			Vector v(*this);
-			v.Serialize(1, serializer);
-			break;
-		}
-		}
-	}
-	writer.Finalize();
-}
-
-Value Value::Deserialize(Deserializer &main_source) {
-	FieldReader reader(main_source);
-	auto type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	auto is_null = reader.ReadRequired<bool>();
-	Value new_value = Value(type);
-	if (is_null) {
-		reader.Finalize();
-		return new_value;
-	}
-	new_value.is_null = false;
-	auto &source = reader.GetSource();
-	switch (type.InternalType()) {
-	case PhysicalType::BOOL:
-		new_value.value_.boolean = source.Read<int8_t>();
-		break;
-	case PhysicalType::INT8:
-		new_value.value_.tinyint = source.Read<int8_t>();
-		break;
-	case PhysicalType::INT16:
-		new_value.value_.smallint = source.Read<int16_t>();
-		break;
-	case PhysicalType::INT32:
-		new_value.value_.integer = source.Read<int32_t>();
-		break;
-	case PhysicalType::INT64:
-		new_value.value_.bigint = source.Read<int64_t>();
-		break;
-	case PhysicalType::UINT8:
-		new_value.value_.utinyint = source.Read<uint8_t>();
-		break;
-	case PhysicalType::UINT16:
-		new_value.value_.usmallint = source.Read<uint16_t>();
-		break;
-	case PhysicalType::UINT32:
-		new_value.value_.uinteger = source.Read<uint32_t>();
-		break;
-	case PhysicalType::UINT64:
-		new_value.value_.ubigint = source.Read<uint64_t>();
-		break;
-	case PhysicalType::INT128:
-		new_value.value_.hugeint = source.Read<hugeint_t>();
-		break;
-	case PhysicalType::FLOAT:
-		new_value.value_.float_ = source.Read<float>();
-		break;
-	case PhysicalType::DOUBLE:
-		new_value.value_.double_ = source.Read<double>();
-		break;
-	case PhysicalType::INTERVAL:
-		new_value.value_.interval = source.Read<interval_t>();
-		break;
-	case PhysicalType::VARCHAR:
-		new_value.value_info_ = make_shared<StringValueInfo>(source.Read<string>());
-		break;
-	default: {
-		Vector v(type);
-		v.Deserialize(1, source);
-		new_value = v.GetValue(0);
-		break;
-	}
-	}
-	reader.Finalize();
-	return new_value;
-}
-
-void Value::FormatSerialize(FormatSerializer &serializer) const {
+void Value::Serialize(Serializer &serializer) const {
 	serializer.WriteProperty(100, "type", type_);
 	serializer.WriteProperty(101, "is_null", is_null);
 	if (!IsNull()) {
@@ -1830,24 +1705,24 @@ void Value::FormatSerialize(FormatSerializer &serializer) const {
 			}
 		} break;
 		case PhysicalType::LIST: {
-			serializer.WriteObject(102, "value", [&](FormatSerializer &serializer) {
+			serializer.WriteObject(102, "value", [&](Serializer &serializer) {
 				auto &children = ListValue::GetChildren(*this);
 				serializer.WriteProperty(100, "children", children);
 			});
 		} break;
 		case PhysicalType::STRUCT: {
-			serializer.WriteObject(102, "value", [&](FormatSerializer &serializer) {
+			serializer.WriteObject(102, "value", [&](Serializer &serializer) {
 				auto &children = StructValue::GetChildren(*this);
 				serializer.WriteProperty(100, "children", children);
 			});
 		} break;
 		default:
-			throw NotImplementedException("Unimplemented type for FormatSerialize");
+			throw NotImplementedException("Unimplemented type for Serialize");
 		}
 	}
 }
 
-Value Value::FormatDeserialize(FormatDeserializer &deserializer) {
+Value Value::Deserialize(Deserializer &deserializer) {
 	auto type = deserializer.ReadProperty<LogicalType>(100, "type");
 	auto is_null = deserializer.ReadProperty<bool>(101, "is_null");
 	Value new_value = Value(type);
@@ -1906,19 +1781,19 @@ Value Value::FormatDeserialize(FormatDeserializer &deserializer) {
 		}
 	} break;
 	case PhysicalType::LIST: {
-		deserializer.ReadObject(102, "value", [&](FormatDeserializer &obj) {
+		deserializer.ReadObject(102, "value", [&](Deserializer &obj) {
 			auto children = obj.ReadProperty<vector<Value>>(100, "children");
 			new_value.value_info_ = make_shared<NestedValueInfo>(children);
 		});
 	} break;
 	case PhysicalType::STRUCT: {
-		deserializer.ReadObject(102, "value", [&](FormatDeserializer &obj) {
+		deserializer.ReadObject(102, "value", [&](Deserializer &obj) {
 			auto children = obj.ReadProperty<vector<Value>>(100, "children");
 			new_value.value_info_ = make_shared<NestedValueInfo>(children);
 		});
 	} break;
 	default:
-		throw NotImplementedException("Unimplemented type for FormatDeserialize");
+		throw NotImplementedException("Unimplemented type for Deserialize");
 	}
 	return new_value;
 }