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

package/src/duckdb/src/planner/operator/logical_pragma.cpp

@@ -2,14 +2,6 @@
 
 namespace duckdb {
 
-void LogicalPragma::Serialize(FieldWriter &writer) const {
-	throw NotImplementedException(LogicalOperatorToString(type));
-}
-
-unique_ptr<LogicalOperator> LogicalPragma::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	throw NotImplementedException(LogicalOperatorToString(state.type));
-}
-
 idx_t LogicalPragma::EstimateCardinality(ClientContext &context) {
 	return 1;
 }

package/src/duckdb/src/planner/operator/logical_prepare.cpp

@@ -2,14 +2,6 @@
 
 namespace duckdb {
 
-void LogicalPrepare::Serialize(FieldWriter &writer) const {
-	throw NotImplementedException(LogicalOperatorToString(type));
-}
-
-unique_ptr<LogicalOperator> LogicalPrepare::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	throw NotImplementedException(LogicalOperatorToString(state.type));
-}
-
 idx_t LogicalPrepare::EstimateCardinality(ClientContext &context) {
 	return 1;
 }

package/src/duckdb/src/planner/operator/logical_projection.cpp

@@ -1,6 +1,5 @@
 #include "duckdb/planner/operator/logical_projection.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/main/config.hpp"
 
 namespace duckdb {
@@ -19,17 +18,6 @@ void LogicalProjection::ResolveTypes() {
 	}
 }
 
-void LogicalProjection::Serialize(FieldWriter &writer) const {
-	writer.WriteField(table_index);
-	writer.WriteSerializableList<Expression>(expressions);
-}
-
-unique_ptr<LogicalOperator> LogicalProjection::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto table_index = reader.ReadRequired<idx_t>();
-	auto expressions = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-	return make_uniq<LogicalProjection>(table_index, std::move(expressions));
-}
-
 vector<idx_t> LogicalProjection::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }

package/src/duckdb/src/planner/operator/logical_recursive_cte.cpp

@@ -1,24 +1,9 @@
 #include "duckdb/planner/operator/logical_recursive_cte.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
-void LogicalRecursiveCTE::Serialize(FieldWriter &writer) const {
-	writer.WriteField(table_index);
-	writer.WriteField(column_count);
-	writer.WriteField(union_all);
-}
-
-unique_ptr<LogicalOperator> LogicalRecursiveCTE::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto result = unique_ptr<LogicalRecursiveCTE>(new LogicalRecursiveCTE());
-	result->table_index = reader.ReadRequired<idx_t>();
-	result->column_count = reader.ReadRequired<idx_t>();
-	result->union_all = reader.ReadRequired<bool>();
-	return std::move(result);
-}
-
 vector<idx_t> LogicalRecursiveCTE::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }

package/src/duckdb/src/planner/operator/logical_reset.cpp

@@ -1,19 +1,7 @@
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/planner/operator/logical_reset.hpp"
 
 namespace duckdb {
 
-void LogicalReset::Serialize(FieldWriter &writer) const {
-	writer.WriteString(name);
-	writer.WriteField(scope);
-}
-
-unique_ptr<LogicalOperator> LogicalReset::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto name = reader.ReadRequired<std::string>();
-	auto scope = reader.ReadRequired<SetScope>();
-	return make_uniq<LogicalReset>(name, scope);
-}
-
 idx_t LogicalReset::EstimateCardinality(ClientContext &context) {
 	return 1;
 }

package/src/duckdb/src/planner/operator/logical_sample.cpp

@@ -1,4 +1,3 @@
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/planner/operator/logical_sample.hpp"
 
 namespace duckdb {
@@ -37,14 +36,4 @@ void LogicalSample::ResolveTypes() {
 	types = children[0]->types;
 }
 
-void LogicalSample::Serialize(FieldWriter &writer) const {
-	sample_options->Serialize(writer.GetSerializer());
-}
-
-unique_ptr<LogicalOperator> LogicalSample::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto sample_options = SampleOptions::Deserialize(reader.GetSource());
-	// TODO(stephwang): review how to pass child LogicalOperator
-	auto result = make_uniq<LogicalSample>(std::move(sample_options), nullptr);
-	return std::move(result);
-}
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_set.cpp

@@ -1,21 +1,7 @@
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/planner/operator/logical_set.hpp"
 
 namespace duckdb {
 
-void LogicalSet::Serialize(FieldWriter &writer) const {
-	writer.WriteString(name);
-	value.Serialize(writer.GetSerializer());
-	writer.WriteField(scope);
-}
-
-unique_ptr<LogicalOperator> LogicalSet::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto name = reader.ReadRequired<std::string>();
-	auto value = Value::Deserialize(reader.GetSource());
-	auto scope = reader.ReadRequired<SetScope>();
-	return make_uniq<LogicalSet>(name, value, scope);
-}
-
 idx_t LogicalSet::EstimateCardinality(ClientContext &context) {
 	return 1;
 }

package/src/duckdb/src/planner/operator/logical_set_operation.cpp

@@ -1,22 +1,9 @@
 #include "duckdb/planner/operator/logical_set_operation.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
-void LogicalSetOperation::Serialize(FieldWriter &writer) const {
-	writer.WriteField(table_index);
-	writer.WriteField(column_count);
-}
-
-unique_ptr<LogicalOperator> LogicalSetOperation::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto table_index = reader.ReadRequired<idx_t>();
-	auto column_count = reader.ReadRequired<idx_t>();
-	// TODO(stephwang): review if unique_ptr<LogicalOperator> plan is needed
-	return unique_ptr<LogicalSetOperation>(new LogicalSetOperation(table_index, column_count, state.type));
-}
-
 vector<idx_t> LogicalSetOperation::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }

package/src/duckdb/src/planner/operator/logical_simple.cpp

@@ -9,66 +9,6 @@
 
 namespace duckdb {
 
-void LogicalSimple::Serialize(FieldWriter &writer) const {
-	writer.WriteField<LogicalOperatorType>(type);
-	switch (type) {
-	case LogicalOperatorType::LOGICAL_ALTER:
-		info->Cast<AlterInfo>().Serialize(writer.GetSerializer());
-		break;
-	case LogicalOperatorType::LOGICAL_DROP:
-		info->Cast<DropInfo>().Serialize(writer.GetSerializer());
-		break;
-	case LogicalOperatorType::LOGICAL_LOAD:
-		info->Cast<LoadInfo>().Serialize(writer.GetSerializer());
-		break;
-	case LogicalOperatorType::LOGICAL_VACUUM:
-		info->Cast<VacuumInfo>().Serialize(writer.GetSerializer());
-		break;
-	case LogicalOperatorType::LOGICAL_ATTACH:
-		info->Cast<AttachInfo>().Serialize(writer.GetSerializer());
-		break;
-	case LogicalOperatorType::LOGICAL_DETACH:
-		info->Cast<DetachInfo>().Serialize(writer.GetSerializer());
-		break;
-	case LogicalOperatorType::LOGICAL_TRANSACTION:
-		info->Cast<TransactionInfo>().Serialize(writer.GetSerializer());
-		break;
-	default:
-		throw InternalException(LogicalOperatorToString(type));
-	}
-}
-
-unique_ptr<LogicalOperator> LogicalSimple::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto type = reader.ReadRequired<LogicalOperatorType>();
-	unique_ptr<ParseInfo> parse_info;
-	switch (type) {
-	case LogicalOperatorType::LOGICAL_ALTER:
-		parse_info = AlterInfo::Deserialize(reader.GetSource());
-		break;
-	case LogicalOperatorType::LOGICAL_DROP:
-		parse_info = DropInfo::Deserialize(reader.GetSource());
-		break;
-	case LogicalOperatorType::LOGICAL_LOAD:
-		parse_info = LoadInfo::Deserialize(reader.GetSource());
-		break;
-	case LogicalOperatorType::LOGICAL_VACUUM:
-		parse_info = VacuumInfo::Deserialize(reader.GetSource());
-		break;
-	case LogicalOperatorType::LOGICAL_ATTACH:
-		parse_info = AttachInfo::Deserialize(reader.GetSource());
-		break;
-	case LogicalOperatorType::LOGICAL_DETACH:
-		parse_info = DetachInfo::Deserialize(reader.GetSource());
-		break;
-	case LogicalOperatorType::LOGICAL_TRANSACTION:
-		parse_info = TransactionInfo::Deserialize(reader.GetSource());
-		break;
-	default:
-		throw InternalException(LogicalOperatorToString(state.type));
-	}
-	return make_uniq<LogicalSimple>(type, std::move(parse_info));
-}
-
 idx_t LogicalSimple::EstimateCardinality(ClientContext &context) {
 	return 1;
 }

package/src/duckdb/src/planner/operator/logical_top_n.cpp

@@ -1,21 +1,7 @@
 #include "duckdb/planner/operator/logical_top_n.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
-void LogicalTopN::Serialize(FieldWriter &writer) const {
-	writer.WriteRegularSerializableList(orders);
-	writer.WriteField(offset);
-	writer.WriteField(limit);
-}
-
-unique_ptr<LogicalOperator> LogicalTopN::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto orders = reader.ReadRequiredSerializableList<BoundOrderByNode, BoundOrderByNode>(state.gstate);
-	auto offset = reader.ReadRequired<idx_t>();
-	auto limit = reader.ReadRequired<idx_t>();
-	return make_uniq<LogicalTopN>(std::move(orders), limit, offset);
-}
-
 idx_t LogicalTopN::EstimateCardinality(ClientContext &context) {
 	auto child_cardinality = LogicalOperator::EstimateCardinality(context);
 	if (limit >= 0 && child_cardinality < idx_t(limit)) {

package/src/duckdb/src/planner/operator/logical_unnest.cpp

@@ -1,6 +1,5 @@
 #include "duckdb/planner/operator/logical_unnest.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/main/config.hpp"
 
 namespace duckdb {
@@ -20,19 +19,6 @@ void LogicalUnnest::ResolveTypes() {
 	}
 }
 
-void LogicalUnnest::Serialize(FieldWriter &writer) const {
-	writer.WriteField(unnest_index);
-	writer.WriteSerializableList<Expression>(expressions);
-}
-
-unique_ptr<LogicalOperator> LogicalUnnest::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto unnest_index = reader.ReadRequired<idx_t>();
-	auto expressions = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-	auto result = make_uniq<LogicalUnnest>(unnest_index);
-	result->expressions = std::move(expressions);
-	return std::move(result);
-}
-
 vector<idx_t> LogicalUnnest::GetTableIndex() const {
 	return vector<idx_t> {unnest_index};
 }

package/src/duckdb/src/planner/operator/logical_update.cpp

@@ -1,5 +1,4 @@
 #include "duckdb/planner/operator/logical_update.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/parser/parsed_data/create_table_info.hpp"
 #include "duckdb/main/config.hpp"
@@ -15,33 +14,6 @@ LogicalUpdate::LogicalUpdate(ClientContext &context, const string &catalog, cons
       table(Catalog::GetEntry<TableCatalogEntry>(context, catalog, schema, table)) {
 }
 
-void LogicalUpdate::Serialize(FieldWriter &writer) const {
-	table.Serialize(writer.GetSerializer());
-	writer.WriteField(table_index);
-	writer.WriteField(return_chunk);
-	writer.WriteIndexList<PhysicalIndex>(columns);
-	writer.WriteSerializableList(bound_defaults);
-	writer.WriteField(update_is_del_and_insert);
-	writer.WriteSerializableList(this->expressions);
-}
-
-unique_ptr<LogicalOperator> LogicalUpdate::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto &context = state.gstate.context;
-	auto info = TableCatalogEntry::Deserialize(reader.GetSource());
-	auto &catalog = Catalog::GetCatalog(context, info->catalog);
-
-	auto &table_catalog_entry =
-	    catalog.GetEntry<TableCatalogEntry>(context, info->schema, info->Cast<CreateTableInfo>().table);
-	auto result = make_uniq<LogicalUpdate>(table_catalog_entry);
-	result->table_index = reader.ReadRequired<idx_t>();
-	result->return_chunk = reader.ReadRequired<bool>();
-	result->columns = reader.ReadRequiredIndexList<PhysicalIndex>();
-	result->bound_defaults = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-	result->update_is_del_and_insert = reader.ReadRequired<bool>();
-	result->expressions = reader.ReadRequiredSerializableList<duckdb::Expression>(state.gstate);
-	return std::move(result);
-}
-
 idx_t LogicalUpdate::EstimateCardinality(ClientContext &context) {
 	return return_chunk ? LogicalOperator::EstimateCardinality(context) : 1;
 }

package/src/duckdb/src/planner/operator/logical_window.cpp

@@ -1,6 +1,5 @@
 #include "duckdb/planner/operator/logical_window.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/main/config.hpp"
 
 namespace duckdb {
@@ -20,18 +19,6 @@ void LogicalWindow::ResolveTypes() {
 	}
 }
 
-void LogicalWindow::Serialize(FieldWriter &writer) const {
-	writer.WriteField(window_index);
-	writer.WriteSerializableList<Expression>(expressions);
-}
-
-unique_ptr<LogicalOperator> LogicalWindow::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto window_index = reader.ReadRequired<idx_t>();
-	auto result = make_uniq<LogicalWindow>(window_index);
-	result->expressions = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-	return std::move(result);
-}
-
 vector<idx_t> LogicalWindow::GetTableIndex() const {
 	return vector<idx_t> {window_index};
 }

package/src/duckdb/src/planner/planner.cpp

@@ -1,7 +1,8 @@
 #include "duckdb/planner/planner.hpp"
 
-#include "duckdb/common/serializer.hpp"
-#include "duckdb/common/serializer/buffered_deserializer.hpp"
+#include "duckdb/common/serializer/binary_deserializer.hpp"
+#include "duckdb/common/serializer/binary_serializer.hpp"
+#include "duckdb/common/serializer/memory_stream.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/client_data.hpp"
@@ -11,8 +12,6 @@
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
 #include "duckdb/transaction/meta_transaction.hpp"
-#include "duckdb/common/serializer/binary_serializer.hpp"
-#include "duckdb/common/serializer/binary_deserializer.hpp"
 
 namespace duckdb {
 
@@ -169,29 +168,21 @@ void Planner::VerifyPlan(ClientContext &context, unique_ptr<LogicalOperator> &op
 
 	// format (de)serialization of this operator
 	try {
-		auto blob = BinarySerializer::Serialize(*op, true);
+		MemoryStream stream;
+		BinarySerializer::Serialize(*op, stream, true);
+		stream.Rewind();
 		bound_parameter_map_t parameters;
-		auto result = BinaryDeserializer::Deserialize<LogicalOperator>(context, parameters, blob.data(), blob.size());
+		auto new_plan = BinaryDeserializer::Deserialize<LogicalOperator>(stream, context, parameters);
+
+		if (map) {
+			*map = std::move(parameters);
+		}
+		op = std::move(new_plan);
 	} catch (SerializationException &ex) {
 		// pass
-	}
-
-	BufferedSerializer serializer;
-	try {
-		op->Serialize(serializer);
 	} catch (NotImplementedException &ex) {
-		// ignore for now (FIXME)
-		return;
-	}
-	auto data = serializer.GetData();
-	auto deserializer = BufferedContextDeserializer(context, data.data.get(), data.size);
-
-	PlanDeserializationState state(context);
-	auto new_plan = LogicalOperator::Deserialize(deserializer, state);
-	if (map) {
-		*map = std::move(state.parameter_data);
+		// pass
 	}
-	op = std::move(new_plan);
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/table_filter.cpp

@@ -1,4 +1,3 @@
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/planner/table_filter.hpp"
 #include "duckdb/planner/filter/conjunction_filter.hpp"
 #include "duckdb/planner/filter/constant_filter.hpp"
@@ -25,62 +24,4 @@ void TableFilterSet::PushFilter(idx_t column_index, unique_ptr<TableFilter> filt
 	}
 }
 
-//! Serializes a LogicalType to a stand-alone binary blob
-void TableFilterSet::Serialize(Serializer &serializer) const {
-	serializer.Write<idx_t>(filters.size());
-	for (auto &entry : filters) {
-		serializer.Write<idx_t>(entry.first);
-		entry.second->Serialize(serializer);
-	}
-}
-
-//! Deserializes a blob back into an LogicalType
-unique_ptr<TableFilterSet> TableFilterSet::Deserialize(Deserializer &source) {
-	auto len = source.Read<idx_t>();
-	auto res = make_uniq<TableFilterSet>();
-	for (idx_t i = 0; i < len; i++) {
-		auto key = source.Read<idx_t>();
-		auto value = TableFilter::Deserialize(source);
-		res->filters[key] = std::move(value);
-	}
-	return res;
-}
-
-//! Serializes a LogicalType to a stand-alone binary blob
-void TableFilter::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField<TableFilterType>(filter_type);
-	Serialize(writer);
-	writer.Finalize();
-}
-
-//! Deserializes a blob back into an LogicalType
-unique_ptr<TableFilter> TableFilter::Deserialize(Deserializer &source) {
-	unique_ptr<TableFilter> result;
-
-	FieldReader reader(source);
-	auto filter_type = reader.ReadRequired<TableFilterType>();
-	switch (filter_type) {
-	case TableFilterType::CONSTANT_COMPARISON:
-		result = ConstantFilter::Deserialize(reader);
-		break;
-	case TableFilterType::CONJUNCTION_AND:
-		result = ConjunctionAndFilter::Deserialize(reader);
-		break;
-	case TableFilterType::CONJUNCTION_OR:
-		result = ConjunctionOrFilter::Deserialize(reader);
-		break;
-	case TableFilterType::IS_NOT_NULL:
-		result = IsNotNullFilter::Deserialize(reader);
-		break;
-	case TableFilterType::IS_NULL:
-		result = IsNullFilter::Deserialize(reader);
-		break;
-	default:
-		throw NotImplementedException("Unsupported table filter type for deserialization");
-	}
-	reader.Finalize();
-	return result;
-}
-
 } // namespace duckdb

package/src/duckdb/src/storage/checkpoint/row_group_writer.cpp

@@ -1,9 +1,7 @@
 #include "duckdb/storage/checkpoint/table_data_writer.hpp"
-
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/common/serializer/buffered_serializer.hpp"
 #include "duckdb/storage/table/column_checkpoint_state.hpp"
+#include "duckdb/common/serializer/binary_serializer.hpp"
 
 namespace duckdb {
 
@@ -19,21 +17,13 @@ PartialBlockAllocation RowGroupWriter::GetBlockAllocation(uint32_t segment_size)
 	return partial_block_manager.GetBlockAllocation(segment_size);
 }
 
-void SingleFileRowGroupWriter::WriteColumnDataPointers(ColumnCheckpointState &column_checkpoint_state) {
-	auto &meta_writer = table_data_writer;
+void SingleFileRowGroupWriter::WriteColumnDataPointers(ColumnCheckpointState &column_checkpoint_state,
+                                                       Serializer &serializer) {
 	const auto &data_pointers = column_checkpoint_state.data_pointers;
-
-	meta_writer.Write<idx_t>(data_pointers.size());
-	// then write the data pointers themselves
-	for (idx_t k = 0; k < data_pointers.size(); k++) {
-		auto &data_pointer = data_pointers[k];
-		meta_writer.Write<idx_t>(data_pointer.row_start);
-		meta_writer.Write<idx_t>(data_pointer.tuple_count);
-		meta_writer.Write<block_id_t>(data_pointer.block_pointer.block_id);
-		meta_writer.Write<uint32_t>(data_pointer.block_pointer.offset);
-		meta_writer.Write<CompressionType>(data_pointer.compression_type);
-		data_pointer.statistics.Serialize(meta_writer);
-	}
+	serializer.WriteList(100, "data_pointers", data_pointers.size(), [&](Serializer::List &list, idx_t i) {
+		auto &data_pointer = data_pointers[i];
+		list.WriteElement(data_pointer);
+	});
 }
 
 MetadataWriter &SingleFileRowGroupWriter::GetPayloadWriter() {

package/src/duckdb/src/storage/checkpoint/table_data_reader.cpp

@@ -1,7 +1,7 @@
 #include "duckdb/storage/checkpoint/table_data_reader.hpp"
 #include "duckdb/storage/metadata/metadata_reader.hpp"
 #include "duckdb/common/types/null_value.hpp"
-
+#include "duckdb/common/serializer/binary_deserializer.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 
 #include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
@@ -18,10 +18,13 @@ void TableDataReader::ReadTableData() {
 	auto &columns = info.Base().columns;
 	D_ASSERT(!columns.empty());
 
-	// deserialize the total table statistics
-	info.data->table_stats.Deserialize(reader, columns);
+	// We stored the table statistics as a unit in FinalizeTable.
+	BinaryDeserializer stats_deserializer(reader);
+	stats_deserializer.Begin();
+	info.data->table_stats.Deserialize(stats_deserializer, columns);
+	stats_deserializer.End();
 
-	// deserialize each of the individual row groups
+	// Deserialize the row group pointers (lazily, just set the count and the pointer to them for now)
 	info.data->row_group_count = reader.Read<uint64_t>();
 	info.data->block_pointer = reader.GetMetaBlockPointer();
 }

package/src/duckdb/src/storage/checkpoint/table_data_writer.cpp

@@ -2,10 +2,9 @@
 
 #include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/common/serializer/buffered_serializer.hpp"
 #include "duckdb/storage/table/column_checkpoint_state.hpp"
 #include "duckdb/storage/table/table_statistics.hpp"
+#include "duckdb/common/serializer/binary_serializer.hpp"
 
 namespace duckdb {
 
@@ -16,9 +15,9 @@ TableDataWriter::TableDataWriter(TableCatalogEntry &table_p) : table(table_p.Cas
 TableDataWriter::~TableDataWriter() {
 }
 
-void TableDataWriter::WriteTableData() {
+void TableDataWriter::WriteTableData(Serializer &metadata_serializer) {
 	// start scanning the table and append the data to the uncompressed segments
-	table.GetStorage().Checkpoint(*this);
+	table.GetStorage().Checkpoint(*this, metadata_serializer);
 }
 
 CompressionType TableDataWriter::GetColumnCompressionType(idx_t i) {
@@ -31,22 +30,25 @@ void TableDataWriter::AddRowGroup(RowGroupPointer &&row_group_pointer, unique_pt
 }
 
 SingleFileTableDataWriter::SingleFileTableDataWriter(SingleFileCheckpointWriter &checkpoint_manager,
-                                                     TableCatalogEntry &table, MetadataWriter &table_data_writer,
-                                                     MetadataWriter &meta_data_writer)
-    : TableDataWriter(table), checkpoint_manager(checkpoint_manager), table_data_writer(table_data_writer),
-      meta_data_writer(meta_data_writer) {
+                                                     TableCatalogEntry &table, MetadataWriter &table_data_writer)
+    : TableDataWriter(table), checkpoint_manager(checkpoint_manager), table_data_writer(table_data_writer) {
 }
 
 unique_ptr<RowGroupWriter> SingleFileTableDataWriter::GetRowGroupWriter(RowGroup &row_group) {
 	return make_uniq<SingleFileRowGroupWriter>(table, checkpoint_manager.partial_block_manager, table_data_writer);
 }
 
-void SingleFileTableDataWriter::FinalizeTable(TableStatistics &&global_stats, DataTableInfo *info) {
+void SingleFileTableDataWriter::FinalizeTable(TableStatistics &&global_stats, DataTableInfo *info,
+                                              Serializer &metadata_serializer) {
 	// store the current position in the metadata writer
 	// this is where the row groups for this table start
 	auto pointer = table_data_writer.GetMetaBlockPointer();
 
-	global_stats.Serialize(table_data_writer);
+	// Serialize statistics as a single unit
+	BinarySerializer stats_serializer(table_data_writer);
+	stats_serializer.Begin();
+	global_stats.Serialize(stats_serializer);
+	stats_serializer.End();
 
 	// now start writing the row group pointers to disk
 	table_data_writer.Write<uint64_t>(row_group_pointers.size());
@@ -56,22 +58,22 @@ void SingleFileTableDataWriter::FinalizeTable(TableStatistics &&global_stats, Da
 		if (row_group_count > total_rows) {
 			total_rows = row_group_count;
 		}
-		RowGroup::Serialize(row_group_pointer, table_data_writer);
-	}
 
-	// Pointer to the table itself goes to the metadata stream.
-	meta_data_writer.Write<idx_t>(pointer.block_pointer);
-	meta_data_writer.Write<uint64_t>(pointer.offset);
-	meta_data_writer.Write<idx_t>(total_rows);
+		// Each RowGroup is its own unit
+		BinarySerializer row_group_serializer(table_data_writer);
+		row_group_serializer.Begin();
+		RowGroup::Serialize(row_group_pointer, row_group_serializer);
+		row_group_serializer.End();
+	}
 
-	// Now we serialize indexes in the table_metadata_writer
+	// TODO: Serialize this:
 	auto index_pointers = info->indexes.SerializeIndexes(table_data_writer);
 
-	// Write-off to metadata block ids and offsets of indexes
-	meta_data_writer.Write<idx_t>(index_pointers.size());
-	for (const auto &index_pointer : index_pointers) {
-		meta_data_writer.Write<BlockPointer>(index_pointer);
-	}
+	// Now begin the metadata as a unit
+	// Pointer to the table itself goes to the metadata stream.
+	metadata_serializer.WriteProperty(101, "table_pointer", pointer);
+	metadata_serializer.WriteProperty(102, "total_rows", total_rows);
+	metadata_serializer.WriteProperty(103, "index_pointers", index_pointers);
 }
 
 } // namespace duckdb