duckdb 0.3.2-dev1175.0 → 0.3.2-dev1197.0

package/src/duckdb.cpp

@@ -853,6 +853,262 @@ string IndexCatalogEntry::ToSQL() {
 } // namespace duckdb
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/field_writer.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+#include <type_traits>
+
+namespace duckdb {
+class BufferedSerializer;
+
+class FieldWriter {
+public:
+	FieldWriter(Serializer &serializer);
+	~FieldWriter();
+
+public:
+	template <class T>
+	void WriteField(const T &element) {
+		static_assert(std::is_trivially_destructible<T>(), "WriteField object must be trivially destructible");
+
+		AddField();
+		WriteData((const_data_ptr_t)&element, sizeof(T));
+	}
+
+	//! Write a string with a length prefix
+	void WriteString(const string &val) {
+		WriteStringLen((const_data_ptr_t)val.c_str(), val.size());
+	}
+	void WriteStringLen(const_data_ptr_t val, idx_t len) {
+		AddField();
+		Write<uint32_t>((uint32_t)len);
+		if (len > 0) {
+			WriteData(val, len);
+		}
+	}
+	void WriteBlob(const_data_ptr_t val, idx_t len) {
+		AddField();
+		if (len > 0) {
+			WriteData(val, len);
+		}
+	}
+
+	template <class T, class CONTAINER_TYPE = vector<T>>
+	void WriteList(const CONTAINER_TYPE &elements) {
+		AddField();
+		Write<uint32_t>(elements.size());
+		for (auto &element : elements) {
+			Write<T>(element);
+		}
+	}
+
+	template <class T>
+	void WriteSerializable(const T &element) {
+		AddField();
+		element.Serialize(*buffer);
+	}
+
+	template <class T>
+	void WriteSerializableList(const vector<unique_ptr<T>> &elements) {
+		AddField();
+		Write<uint32_t>(elements.size());
+		for (idx_t i = 0; i < elements.size(); i++) {
+			elements[i]->Serialize(*buffer);
+		}
+	}
+
+	template <class T>
+	void WriteRegularSerializableList(const vector<T> &elements) {
+		AddField();
+		Write<uint32_t>(elements.size());
+		for (idx_t i = 0; i < elements.size(); i++) {
+			elements[i].Serialize(*buffer);
+		}
+	}
+
+	template <class T>
+	void WriteOptional(const unique_ptr<T> &element) {
+		AddField();
+		Write<bool>(element ? true : false);
+		if (element) {
+			element->Serialize(*buffer);
+		}
+	}
+
+	// Called after all fields have been written. Should always be called.
+	void Finalize();
+
+	Serializer &GetSerializer() {
+		return *buffer;
+	}
+
+private:
+	void AddField() {
+		field_count++;
+	}
+
+	template <class T>
+	void Write(const T &element) {
+		WriteData((const_data_ptr_t)&element, sizeof(T));
+	}
+
+	void WriteData(const_data_ptr_t buffer, idx_t write_size);
+
+private:
+	Serializer &serializer;
+	unique_ptr<BufferedSerializer> buffer;
+	idx_t field_count;
+};
+
+template <>
+void FieldWriter::Write(const string &val);
+
+class FieldDeserializer : public Deserializer {
+public:
+	FieldDeserializer(Deserializer &root);
+
+public:
+	void ReadData(data_ptr_t buffer, idx_t read_size) override;
+
+	void SetRemainingData(idx_t remaining_data);
+	idx_t RemainingData();
+
+private:
+	Deserializer &root;
+	idx_t remaining_data;
+};
+
+class FieldReader {
+public:
+	FieldReader(Deserializer &source);
+	~FieldReader();
+
+public:
+	template <class T>
+	T ReadRequired() {
+		if (field_count >= max_field_count) {
+			// field is not there, throw an exception
+			throw SerializationException("Attempting to read a required field, but field is missing");
+		}
+		// field is there, read the actual value
+		AddField();
+		return source.Read<T>();
+	}
+
+	template <class T>
+	T ReadField(T default_value) {
+		if (field_count >= max_field_count) {
+			// field is not there, read the default value
+			return default_value;
+		}
+		// field is there, read the actual value
+		AddField();
+		return source.Read<T>();
+	}
+
+	template <class T>
+	vector<T> ReadRequiredList() {
+		if (field_count >= max_field_count) {
+			// field is not there, throw an exception
+			throw SerializationException("Attempting to read a required field, but field is missing");
+		}
+		AddField();
+		auto result_count = source.Read<uint32_t>();
+		vector<T> result;
+		for (idx_t i = 0; i < result_count; i++) {
+			result.push_back(source.Read<T>());
+		}
+		return result;
+	}
+
+	template <class T>
+	unique_ptr<T> ReadOptional(unique_ptr<T> default_value) {
+		if (field_count >= max_field_count) {
+			// field is not there, read the default value
+			return default_value;
+		}
+		// field is there, read the actual value
+		AddField();
+		return source.template ReadOptional<T>();
+	}
+
+	template <class T, class RETURN_TYPE = unique_ptr<T>>
+	RETURN_TYPE ReadSerializable(RETURN_TYPE default_value) {
+		if (field_count >= max_field_count) {
+			// field is not there, read the default value
+			return default_value;
+		}
+		// field is there, read the actual value
+		AddField();
+		return T::Deserialize(source);
+	}
+
+	template <class T, class RETURN_TYPE = unique_ptr<T>>
+	RETURN_TYPE ReadRequiredSerializable() {
+		if (field_count >= max_field_count) {
+			// field is not there, read the default value
+			throw SerializationException("Attempting to read mandatory field, but field is missing");
+		}
+		// field is there, read the actual value
+		AddField();
+		return T::Deserialize(source);
+	}
+
+	template <class T, class RETURN_TYPE = unique_ptr<T>>
+	vector<RETURN_TYPE> ReadRequiredSerializableList() {
+		if (field_count >= max_field_count) {
+			// field is not there, read the default value
+			throw SerializationException("Attempting to read mandatory field, but field is missing");
+		}
+		// field is there, read the actual value
+		AddField();
+		auto result_count = source.Read<uint32_t>();
+
+		vector<RETURN_TYPE> result;
+		for (idx_t i = 0; i < result_count; i++) {
+			result.push_back(T::Deserialize(source));
+		}
+		return result;
+	}
+	void ReadBlob(data_ptr_t result, idx_t read_size) {
+		if (field_count >= max_field_count) {
+			// field is not there, throw an exception
+			throw SerializationException("Attempting to read a required field, but field is missing");
+		}
+		// field is there, read the actual value
+		AddField();
+		source.ReadData(result, read_size);
+	}
+
+	//! Called after all fields have been read. Should always be called.
+	void Finalize();
+
+	Deserializer &GetSource() {
+		return source;
+	}
+
+private:
+	void AddField() {
+		field_count++;
+	}
+
+private:
+	FieldDeserializer source;
+	idx_t field_count;
+	idx_t max_field_count;
+	idx_t total_size;
+};
+
+} // namespace duckdb
 
 
 namespace duckdb {
@@ -863,36 +1119,39 @@ MacroCatalogEntry::MacroCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schem
 	this->internal = info->internal;
 }
 
-void MacroCatalogEntry::Serialize(Serializer &serializer) {
+void MacroCatalogEntry::Serialize(Serializer &main_serializer) {
 	D_ASSERT(!internal);
-	serializer.WriteString(schema->name);
-	serializer.WriteString(name);
-	function->expression->Serialize(serializer);
-	serializer.Write<uint32_t>((uint32_t)function->parameters.size());
-	for (auto &param : function->parameters) {
-		param->Serialize(serializer);
-	}
-	serializer.Write<uint32_t>((uint32_t)function->default_parameters.size());
+	FieldWriter writer(main_serializer);
+	writer.WriteString(schema->name);
+	writer.WriteString(name);
+	writer.WriteSerializable(*function->expression);
+	writer.WriteSerializableList(function->parameters);
+	writer.WriteField<uint32_t>((uint32_t)function->default_parameters.size());
+	auto &serializer = writer.GetSerializer();
 	for (auto &kv : function->default_parameters) {
 		serializer.WriteString(kv.first);
 		kv.second->Serialize(serializer);
 	}
+	writer.Finalize();
 }
 
-unique_ptr<CreateMacroInfo> MacroCatalogEntry::Deserialize(Deserializer &source) {
+unique_ptr<CreateMacroInfo> MacroCatalogEntry::Deserialize(Deserializer &main_source) {
 	auto info = make_unique<CreateMacroInfo>();
-	info->schema = source.Read<string>();
-	info->name = source.Read<string>();
-	info->function = make_unique<MacroFunction>(ParsedExpression::Deserialize(source));
-	auto param_count = source.Read<uint32_t>();
-	for (idx_t i = 0; i < param_count; i++) {
-		info->function->parameters.push_back(ParsedExpression::Deserialize(source));
-	}
-	auto default_param_count = source.Read<uint32_t>();
+
+	FieldReader reader(main_source);
+	info->schema = reader.ReadRequired<string>();
+	info->name = reader.ReadRequired<string>();
+	auto expression = reader.ReadRequiredSerializable<ParsedExpression>();
+	info->function = make_unique<MacroFunction>(move(expression));
+	info->function->parameters = reader.ReadRequiredSerializableList<ParsedExpression>();
+	auto default_param_count = reader.ReadRequired<uint32_t>();
+	auto &source = reader.GetSource();
 	for (idx_t i = 0; i < default_param_count; i++) {
 		auto name = source.Read<string>();
 		info->function->default_parameters[name] = ParsedExpression::Deserialize(source);
 	}
+	reader.Finalize();
+
 	return info;
 }
 
@@ -945,7 +1204,7 @@ public:
 	//! Create a TypeCatalogEntry and initialize storage for it
 	TypeCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateTypeInfo *info);
 
-	unique_ptr<LogicalType> user_type;
+	LogicalType user_type;
 
 public:
 	//! Serialize the meta information of the TypeCatalogEntry a serializer
@@ -1238,12 +1497,18 @@ void SchemaCatalogEntry::Scan(CatalogType type, const std::function<void(Catalog
 }
 
 void SchemaCatalogEntry::Serialize(Serializer &serializer) {
-	serializer.WriteString(name);
+	FieldWriter writer(serializer);
+	writer.WriteString(name);
+	writer.Finalize();
 }
 
 unique_ptr<CreateSchemaInfo> SchemaCatalogEntry::Deserialize(Deserializer &source) {
 	auto info = make_unique<CreateSchemaInfo>();
-	info->schema = source.Read<string>();
+
+	FieldReader reader(source);
+	info->schema = reader.ReadRequired<string>();
+	reader.Finalize();
+
 	return info;
 }
 
@@ -1303,28 +1568,32 @@ SequenceCatalogEntry::SequenceCatalogEntry(Catalog *catalog, SchemaCatalogEntry
 }
 
 void SequenceCatalogEntry::Serialize(Serializer &serializer) {
-	serializer.WriteString(schema->name);
-	serializer.WriteString(name);
-	// serializer.Write<int64_t>(counter);
-	serializer.Write<uint64_t>(usage_count);
-	serializer.Write<int64_t>(increment);
-	serializer.Write<int64_t>(min_value);
-	serializer.Write<int64_t>(max_value);
-	serializer.Write<int64_t>(counter);
-	serializer.Write<bool>(cycle);
+	FieldWriter writer(serializer);
+	writer.WriteString(schema->name);
+	writer.WriteString(name);
+	writer.WriteField<uint64_t>(usage_count);
+	writer.WriteField<int64_t>(increment);
+	writer.WriteField<int64_t>(min_value);
+	writer.WriteField<int64_t>(max_value);
+	writer.WriteField<int64_t>(counter);
+	writer.WriteField<bool>(cycle);
+	writer.Finalize();
 }
 
 unique_ptr<CreateSequenceInfo> SequenceCatalogEntry::Deserialize(Deserializer &source) {
 	auto info = make_unique<CreateSequenceInfo>();
-	info->schema = source.Read<string>();
-	info->name = source.Read<string>();
-	// info->counter = source.Read<int64_t>();
-	info->usage_count = source.Read<uint64_t>();
-	info->increment = source.Read<int64_t>();
-	info->min_value = source.Read<int64_t>();
-	info->max_value = source.Read<int64_t>();
-	info->start_value = source.Read<int64_t>();
-	info->cycle = source.Read<bool>();
+
+	FieldReader reader(source);
+	info->schema = reader.ReadRequired<string>();
+	info->name = reader.ReadRequired<string>();
+	info->usage_count = reader.ReadRequired<uint64_t>();
+	info->increment = reader.ReadRequired<int64_t>();
+	info->min_value = reader.ReadRequired<int64_t>();
+	info->max_value = reader.ReadRequired<int64_t>();
+	info->start_value = reader.ReadRequired<int64_t>();
+	info->cycle = reader.ReadRequired<bool>();
+	reader.Finalize();
+
 	return info;
 }
 
@@ -1375,12 +1644,10 @@ public:
 public:
 	DUCKDB_API string ToString() const override;
 
-	DUCKDB_API unique_ptr<Constraint> Copy() override;
+	DUCKDB_API unique_ptr<Constraint> Copy() const override;
 
-	//! Serialize to a stand-alone binary blob
-	DUCKDB_API void Serialize(Serializer &serializer) override;
-	//! Deserializes a CheckConstraint
-	DUCKDB_API static unique_ptr<Constraint> Deserialize(Deserializer &source);
+	DUCKDB_API void Serialize(FieldWriter &writer) const override;
+	DUCKDB_API static unique_ptr<Constraint> Deserialize(FieldReader &source);
 };
 
 } // namespace duckdb
@@ -1417,12 +1684,12 @@ public:
 public:
 	DUCKDB_API string ToString() const override;
 
-	DUCKDB_API unique_ptr<Constraint> Copy() override;
+	DUCKDB_API unique_ptr<Constraint> Copy() const override;
 
 	//! Serialize to a stand-alone binary blob
-	DUCKDB_API void Serialize(Serializer &serializer) override;
+	DUCKDB_API void Serialize(FieldWriter &writer) const override;
 	//! Deserializes a ParsedConstraint
-	DUCKDB_API static unique_ptr<Constraint> Deserialize(Deserializer &source);
+	DUCKDB_API static unique_ptr<Constraint> Deserialize(FieldReader &source);
 };
 
 } // namespace duckdb
@@ -2398,6 +2665,7 @@ public:
 } // namespace duckdb
 
 
+
 #include <algorithm>
 #include <sstream>
 
@@ -2760,18 +3028,26 @@ vector<LogicalType> TableCatalogEntry::GetTypes() {
 
 void TableCatalogEntry::Serialize(Serializer &serializer) {
 	D_ASSERT(!internal);
-	serializer.WriteString(schema->name);
-	serializer.WriteString(name);
-	D_ASSERT(columns.size() <= NumericLimits<uint32_t>::Maximum());
-	serializer.Write<uint32_t>((uint32_t)columns.size());
-	for (auto &column : columns) {
-		column.Serialize(serializer);
-	}
-	D_ASSERT(constraints.size() <= NumericLimits<uint32_t>::Maximum());
-	serializer.Write<uint32_t>((uint32_t)constraints.size());
-	for (auto &constraint : constraints) {
-		constraint->Serialize(serializer);
-	}
+
+	FieldWriter writer(serializer);
+	writer.WriteString(schema->name);
+	writer.WriteString(name);
+	writer.WriteRegularSerializableList(columns);
+	writer.WriteSerializableList(constraints);
+	writer.Finalize();
+}
+
+unique_ptr<CreateTableInfo> TableCatalogEntry::Deserialize(Deserializer &source) {
+	auto info = make_unique<CreateTableInfo>();
+
+	FieldReader reader(source);
+	info->schema = reader.ReadRequired<string>();
+	info->table = reader.ReadRequired<string>();
+	info->columns = reader.ReadRequiredSerializableList<ColumnDefinition, ColumnDefinition>();
+	info->constraints = reader.ReadRequiredSerializableList<Constraint>();
+	reader.Finalize();
+
+	return info;
 }
 
 string TableCatalogEntry::ToSQL() {
@@ -2856,26 +3132,6 @@ string TableCatalogEntry::ToSQL() {
 	return ss.str();
 }
 
-unique_ptr<CreateTableInfo> TableCatalogEntry::Deserialize(Deserializer &source) {
-	auto info = make_unique<CreateTableInfo>();
-
-	info->schema = source.Read<string>();
-	info->table = source.Read<string>();
-	auto column_count = source.Read<uint32_t>();
-
-	for (uint32_t i = 0; i < column_count; i++) {
-		auto column = ColumnDefinition::Deserialize(source);
-		info->columns.push_back(move(column));
-	}
-	auto constraint_count = source.Read<uint32_t>();
-
-	for (uint32_t i = 0; i < constraint_count; i++) {
-		auto constraint = Constraint::Deserialize(source);
-		info->constraints.push_back(move(constraint));
-	}
-	return info;
-}
-
 unique_ptr<CatalogEntry> TableCatalogEntry::Copy(ClientContext &context) {
 	auto create_info = make_unique<CreateTableInfo>(schema->name, name);
 	for (idx_t i = 0; i < columns.size(); i++) {
@@ -2959,30 +3215,35 @@ TableFunctionCatalogEntry::TableFunctionCatalogEntry(Catalog *catalog, SchemaCat
 namespace duckdb {
 
 TypeCatalogEntry::TypeCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateTypeInfo *info)
-    : StandardEntry(CatalogType::TYPE_ENTRY, schema, catalog, info->name) {
-	user_type = make_unique<LogicalType>(*info->type);
+    : StandardEntry(CatalogType::TYPE_ENTRY, schema, catalog, info->name), user_type(info->type) {
 }
 
 void TypeCatalogEntry::Serialize(Serializer &serializer) {
-	serializer.WriteString(schema->name);
-	serializer.WriteString(name);
-	user_type->Serialize(serializer);
+	FieldWriter writer(serializer);
+	writer.WriteString(schema->name);
+	writer.WriteString(name);
+	writer.WriteSerializable(user_type);
+	writer.Finalize();
 }
 
 unique_ptr<CreateTypeInfo> TypeCatalogEntry::Deserialize(Deserializer &source) {
 	auto info = make_unique<CreateTypeInfo>();
-	info->schema = source.Read<string>();
-	info->name = source.Read<string>();
-	info->type = make_unique<LogicalType>(LogicalType::Deserialize(source));
+
+	FieldReader reader(source);
+	info->schema = reader.ReadRequired<string>();
+	info->name = reader.ReadRequired<string>();
+	info->type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
+	reader.Finalize();
+
 	return info;
 }
 
 string TypeCatalogEntry::ToSQL() {
 	std::stringstream ss;
-	switch (user_type->id()) {
+	switch (user_type.id()) {
 	case (LogicalTypeId::ENUM): {
-		Vector values_insert_order(EnumType::GetValuesInsertOrder(*user_type));
-		idx_t size = EnumType::GetSize(*user_type);
+		Vector values_insert_order(EnumType::GetValuesInsertOrder(user_type));
+		idx_t size = EnumType::GetSize(user_type);
 		ss << "CREATE TYPE ";
 		ss << name;
 		ss << " AS ENUM ( ";
@@ -3051,35 +3312,28 @@ unique_ptr<CatalogEntry> ViewCatalogEntry::AlterEntry(ClientContext &context, Al
 
 void ViewCatalogEntry::Serialize(Serializer &serializer) {
 	D_ASSERT(!internal);
-	serializer.WriteString(schema->name);
-	serializer.WriteString(name);
-	serializer.WriteString(sql);
-	query->Serialize(serializer);
-	D_ASSERT(aliases.size() <= NumericLimits<uint32_t>::Maximum());
-	serializer.Write<uint32_t>((uint32_t)aliases.size());
-	for (auto &alias : aliases) {
-		serializer.WriteString(alias);
-	}
-	serializer.Write<uint32_t>((uint32_t)types.size());
-	for (auto &sql_type : types) {
-		sql_type.Serialize(serializer);
-	}
+	FieldWriter writer(serializer);
+	writer.WriteString(schema->name);
+	writer.WriteString(name);
+	writer.WriteString(sql);
+	writer.WriteSerializable(*query);
+	writer.WriteList<string>(aliases);
+	writer.WriteRegularSerializableList<LogicalType>(types);
+	writer.Finalize();
 }
 
 unique_ptr<CreateViewInfo> ViewCatalogEntry::Deserialize(Deserializer &source) {
 	auto info = make_unique<CreateViewInfo>();
-	info->schema = source.Read<string>();
-	info->view_name = source.Read<string>();
-	info->sql = source.Read<string>();
-	info->query = SelectStatement::Deserialize(source);
-	auto alias_count = source.Read<uint32_t>();
-	for (uint32_t i = 0; i < alias_count; i++) {
-		info->aliases.push_back(source.Read<string>());
-	}
-	auto type_count = source.Read<uint32_t>();
-	for (uint32_t i = 0; i < type_count; i++) {
-		info->types.push_back(LogicalType::Deserialize(source));
-	}
+
+	FieldReader reader(source);
+	info->schema = reader.ReadRequired<string>();
+	info->view_name = reader.ReadRequired<string>();
+	info->sql = reader.ReadRequired<string>();
+	info->query = reader.ReadRequiredSerializable<SelectStatement>();
+	info->aliases = reader.ReadRequiredList<string>();
+	info->types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
+	reader.Finalize();
+
 	return info;
 }
 
@@ -4265,7 +4519,7 @@ void DependencyManager::AlterObject(ClientContext &context, CatalogEntry *old_ob
 			auto table = (TableCatalogEntry *)new_obj;
 			bool deleted_dependency = true;
 			for (auto &column : table->columns) {
-				if (column.type == *user_type->user_type) {
+				if (column.type == user_type->user_type) {
 					deleted_dependency = false;
 					break;
 				}
@@ -11993,6 +12247,92 @@ string ExceptionFormatValue::Format(const string &msg, vector<ExceptionFormatVal
 } // namespace duckdb
 
 
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// Field Writer
+//===--------------------------------------------------------------------===//
+FieldWriter::FieldWriter(Serializer &serializer_p)
+    : serializer(serializer_p), buffer(make_unique<BufferedSerializer>()), field_count(0) {
+}
+
+FieldWriter::~FieldWriter() {
+	if (Exception::UncaughtException()) {
+		return;
+	}
+	// finalize should always have been called, unless this is destroyed as part of stack unwinding
+	D_ASSERT(!buffer);
+}
+
+void FieldWriter::WriteData(const_data_ptr_t buffer_ptr, idx_t write_size) {
+	D_ASSERT(buffer);
+	buffer->WriteData(buffer_ptr, write_size);
+}
+
+template <>
+void FieldWriter::Write(const string &val) {
+	Write<uint32_t>((uint32_t)val.size());
+	if (!val.empty()) {
+		WriteData((const_data_ptr_t)val.c_str(), val.size());
+	}
+}
+
+void FieldWriter::Finalize() {
+	D_ASSERT(buffer);
+
+	serializer.Write<uint32_t>(field_count);
+	serializer.Write<uint64_t>(buffer->blob.size);
+	serializer.WriteData(buffer->blob.data.get(), buffer->blob.size);
+
+	buffer.reset();
+}
+
+//===--------------------------------------------------------------------===//
+// Field Deserializer
+//===--------------------------------------------------------------------===//
+FieldDeserializer::FieldDeserializer(Deserializer &root) : root(root), remaining_data(idx_t(-1)) {
+}
+
+void FieldDeserializer::ReadData(data_ptr_t buffer, idx_t read_size) {
+	D_ASSERT(remaining_data != idx_t(-1));
+	D_ASSERT(read_size <= remaining_data);
+	root.ReadData(buffer, read_size);
+	remaining_data -= read_size;
+}
+
+idx_t FieldDeserializer::RemainingData() {
+	return remaining_data;
+}
+
+void FieldDeserializer::SetRemainingData(idx_t remaining_data) {
+	this->remaining_data = remaining_data;
+}
+
+//===--------------------------------------------------------------------===//
+// Field Reader
+//===--------------------------------------------------------------------===//
+FieldReader::FieldReader(Deserializer &source_p) : source(source_p), field_count(0) {
+	max_field_count = source_p.Read<uint32_t>();
+	total_size = source_p.Read<uint64_t>();
+	D_ASSERT(max_field_count > 0);
+	source.SetRemainingData(total_size);
+}
+
+FieldReader::~FieldReader() {
+}
+
+void FieldReader::Finalize() {
+	if (field_count < max_field_count) {
+		// we can handle this case by calling source.ReadData(buffer, source.RemainingData())
+		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.");
+	}
+	D_ASSERT(source.RemainingData() == 0);
+}
+
+} // namespace duckdb
+
+
 
 
 
@@ -23894,6 +24234,9 @@ namespace duckdb {
 template <>
 string Deserializer::Read() {
 	uint32_t size = Read<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);
@@ -35503,10 +35846,12 @@ bool Value::TryCastAs(const LogicalType &target_type, bool strict) {
 	return true;
 }
 
-void Value::Serialize(Serializer &serializer) {
-	type_.Serialize(serializer);
-	serializer.Write<bool>(IsNull());
+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);
@@ -35557,16 +35902,19 @@ void Value::Serialize(Serializer &serializer) {
 		}
 		}
 	}
+	writer.Finalize();
 }
 
-Value Value::Deserialize(Deserializer &source) {
-	auto type = LogicalType::Deserialize(source);
-	auto is_null = source.Read<bool>();
+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) {
 		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>();
@@ -35613,9 +35961,11 @@ Value Value::Deserialize(Deserializer &source) {
 	default: {
 		Vector v(type);
 		v.Deserialize(1, source);
-		return v.GetValue(0);
+		new_value = v.GetValue(0);
+		break;
 	}
 	}
+	reader.Finalize();
 	return new_value;
 }
 
@@ -35688,8 +36038,6 @@ bool Value::IsValid(double value) {
 
 
 
-
-
 #include <cstring> // strlen() on Solaris
 
 namespace duckdb {
@@ -38181,13 +38529,13 @@ struct ExtraTypeInfo {
 	ExtraTypeInfoType type;
 
 public:
-	virtual bool Equals(ExtraTypeInfo *other) = 0;
+	virtual bool Equals(ExtraTypeInfo *other) const = 0;
 	//! Serializes a ExtraTypeInfo to a stand-alone binary blob
-	virtual void Serialize(Serializer &serializer) = 0;
+	virtual void Serialize(FieldWriter &writer) const = 0;
 	//! Serializes a ExtraTypeInfo to a stand-alone binary blob
-	static void Serialize(ExtraTypeInfo *info, Serializer &serializer);
+	static void Serialize(ExtraTypeInfo *info, FieldWriter &writer);
 	//! Deserializes a blob back into an ExtraTypeInfo
-	static shared_ptr<ExtraTypeInfo> Deserialize(Deserializer &source);
+	static shared_ptr<ExtraTypeInfo> Deserialize(FieldReader &reader);
 };
 
 //===--------------------------------------------------------------------===//
@@ -38202,7 +38550,7 @@ struct DecimalTypeInfo : public ExtraTypeInfo {
 	uint8_t scale;
 
 public:
-	bool Equals(ExtraTypeInfo *other_p) override {
+	bool Equals(ExtraTypeInfo *other_p) const override {
 		if (!other_p) {
 			return false;
 		}
@@ -38213,14 +38561,14 @@ public:
 		return width == other.width && scale == other.scale;
 	}
 
-	void Serialize(Serializer &serializer) override {
-		serializer.Write<uint8_t>(width);
-		serializer.Write<uint8_t>(scale);
+	void Serialize(FieldWriter &writer) const override {
+		writer.WriteField<uint8_t>(width);
+		writer.WriteField<uint8_t>(scale);
 	}
 
-	static shared_ptr<ExtraTypeInfo> Deserialize(Deserializer &source) {
-		auto width = source.Read<uint8_t>();
-		auto scale = source.Read<uint8_t>();
+	static shared_ptr<ExtraTypeInfo> Deserialize(FieldReader &reader) {
+		auto width = reader.ReadRequired<uint8_t>();
+		auto scale = reader.ReadRequired<uint8_t>();
 		return make_shared<DecimalTypeInfo>(width, scale);
 	}
 };
@@ -38255,17 +38603,17 @@ struct StringTypeInfo : public ExtraTypeInfo {
 	string collation;
 
 public:
-	bool Equals(ExtraTypeInfo *other_p) override {
+	bool Equals(ExtraTypeInfo *other_p) const override {
 		// collation info has no impact on equality
 		return true;
 	}
 
-	void Serialize(Serializer &serializer) override {
-		serializer.WriteString(collation);
+	void Serialize(FieldWriter &writer) const override {
+		writer.WriteString(collation);
 	}
 
-	static shared_ptr<ExtraTypeInfo> Deserialize(Deserializer &source) {
-		auto collation = source.Read<string>();
+	static shared_ptr<ExtraTypeInfo> Deserialize(FieldReader &reader) {
+		auto collation = reader.ReadRequired<string>();
 		return make_shared<StringTypeInfo>(move(collation));
 	}
 };
@@ -38297,7 +38645,7 @@ struct ListTypeInfo : public ExtraTypeInfo {
 	LogicalType child_type;
 
 public:
-	bool Equals(ExtraTypeInfo *other_p) override {
+	bool Equals(ExtraTypeInfo *other_p) const override {
 		if (!other_p) {
 			return false;
 		}
@@ -38308,12 +38656,12 @@ public:
 		return child_type == other.child_type;
 	}
 
-	void Serialize(Serializer &serializer) override {
-		child_type.Serialize(serializer);
+	void Serialize(FieldWriter &writer) const override {
+		writer.WriteSerializable(child_type);
 	}
 
-	static shared_ptr<ExtraTypeInfo> Deserialize(Deserializer &source) {
-		auto child_type = LogicalType::Deserialize(source);
+	static shared_ptr<ExtraTypeInfo> Deserialize(FieldReader &reader) {
+		auto child_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
 		return make_shared<ListTypeInfo>(move(child_type));
 	}
 };
@@ -38341,7 +38689,7 @@ struct StructTypeInfo : public ExtraTypeInfo {
 	child_list_t<LogicalType> child_types;
 
 public:
-	bool Equals(ExtraTypeInfo *other_p) override {
+	bool Equals(ExtraTypeInfo *other_p) const override {
 		if (!other_p) {
 			return false;
 		}
@@ -38352,17 +38700,19 @@ public:
 		return child_types == other.child_types;
 	}
 
-	void Serialize(Serializer &serializer) override {
-		serializer.Write<uint32_t>(child_types.size());
+	void Serialize(FieldWriter &writer) const override {
+		writer.WriteField<uint32_t>(child_types.size());
+		auto &serializer = writer.GetSerializer();
 		for (idx_t i = 0; i < child_types.size(); i++) {
 			serializer.WriteString(child_types[i].first);
 			child_types[i].second.Serialize(serializer);
 		}
 	}
 
-	static shared_ptr<ExtraTypeInfo> Deserialize(Deserializer &source) {
+	static shared_ptr<ExtraTypeInfo> Deserialize(FieldReader &reader) {
 		child_list_t<LogicalType> child_list;
-		auto child_types_size = source.Read<uint32_t>();
+		auto child_types_size = reader.ReadRequired<uint32_t>();
+		auto &source = reader.GetSource();
 		for (uint32_t i = 0; i < child_types_size; i++) {
 			auto name = source.Read<string>();
 			auto type = LogicalType::Deserialize(source);
@@ -38436,7 +38786,7 @@ struct UserTypeInfo : public ExtraTypeInfo {
 	string user_type_name;
 
 public:
-	bool Equals(ExtraTypeInfo *other_p) override {
+	bool Equals(ExtraTypeInfo *other_p) const override {
 		if (!other_p) {
 			return false;
 		}
@@ -38447,12 +38797,12 @@ public:
 		return other.user_type_name == user_type_name;
 	}
 
-	void Serialize(Serializer &serializer) override {
-		serializer.WriteString(user_type_name);
+	void Serialize(FieldWriter &writer) const override {
+		writer.WriteString(user_type_name);
 	}
 
-	static shared_ptr<ExtraTypeInfo> Deserialize(Deserializer &source) {
-		auto enum_name = source.Read<string>();
+	static shared_ptr<ExtraTypeInfo> Deserialize(FieldReader &reader) {
+		auto enum_name = reader.ReadRequired<string>();
 		return make_shared<UserTypeInfo>(move(enum_name));
 	}
 };
@@ -38484,7 +38834,7 @@ struct EnumTypeInfo : public ExtraTypeInfo {
 
 public:
 	// Equalities are only used in enums with different catalog entries
-	bool Equals(ExtraTypeInfo *other_p) override {
+	bool Equals(ExtraTypeInfo *other_p) const override {
 		if (!other_p) {
 			return false;
 		}
@@ -38508,10 +38858,11 @@ public:
 		}
 		return true;
 	}
-	void Serialize(Serializer &serializer) override {
-		serializer.Write<uint32_t>(size);
-		serializer.WriteString(enum_name);
-		values_insert_order.Serialize(size, serializer);
+
+	void Serialize(FieldWriter &writer) const override {
+		writer.WriteField<uint32_t>(size);
+		writer.WriteString(enum_name);
+		((Vector &)values_insert_order).Serialize(size, writer.GetSerializer());
 	}
 };
 
@@ -38523,10 +38874,11 @@ struct EnumTypeInfoTemplated : public EnumTypeInfo {
 			values[values_insert_order_p.GetValue(count).ToString()] = count;
 		}
 	}
-	static shared_ptr<EnumTypeInfoTemplated> Deserialize(Deserializer &source, uint32_t size) {
-		auto enum_name = source.Read<string>();
+
+	static shared_ptr<EnumTypeInfoTemplated> Deserialize(FieldReader &reader, uint32_t size) {
+		auto enum_name = reader.ReadRequired<string>();
 		Vector values_insert_order(LogicalType::VARCHAR, size);
-		values_insert_order.Deserialize(size, source);
+		values_insert_order.Deserialize(size, reader.GetSource());
 		return make_shared<EnumTypeInfoTemplated>(move(enum_name), values_insert_order, size);
 	}
 	unordered_map<string, T> values;
@@ -38630,39 +38982,39 @@ PhysicalType EnumType::GetPhysicalType(idx_t size) {
 //===--------------------------------------------------------------------===//
 // Extra Type Info
 //===--------------------------------------------------------------------===//
-void ExtraTypeInfo::Serialize(ExtraTypeInfo *info, Serializer &serializer) {
+void ExtraTypeInfo::Serialize(ExtraTypeInfo *info, FieldWriter &writer) {
 	if (!info) {
-		serializer.Write<ExtraTypeInfoType>(ExtraTypeInfoType::INVALID_TYPE_INFO);
+		writer.WriteField<ExtraTypeInfoType>(ExtraTypeInfoType::INVALID_TYPE_INFO);
 	} else {
-		serializer.Write<ExtraTypeInfoType>(info->type);
-		info->Serialize(serializer);
+		writer.WriteField<ExtraTypeInfoType>(info->type);
+		info->Serialize(writer);
 	}
 }
-shared_ptr<ExtraTypeInfo> ExtraTypeInfo::Deserialize(Deserializer &source) {
-	auto type = source.Read<ExtraTypeInfoType>();
+shared_ptr<ExtraTypeInfo> ExtraTypeInfo::Deserialize(FieldReader &reader) {
+	auto type = reader.ReadRequired<ExtraTypeInfoType>();
 	switch (type) {
 	case ExtraTypeInfoType::INVALID_TYPE_INFO:
 		return nullptr;
 	case ExtraTypeInfoType::DECIMAL_TYPE_INFO:
-		return DecimalTypeInfo::Deserialize(source);
+		return DecimalTypeInfo::Deserialize(reader);
 	case ExtraTypeInfoType::STRING_TYPE_INFO:
-		return StringTypeInfo::Deserialize(source);
+		return StringTypeInfo::Deserialize(reader);
 	case ExtraTypeInfoType::LIST_TYPE_INFO:
-		return ListTypeInfo::Deserialize(source);
+		return ListTypeInfo::Deserialize(reader);
 	case ExtraTypeInfoType::STRUCT_TYPE_INFO:
-		return StructTypeInfo::Deserialize(source);
+		return StructTypeInfo::Deserialize(reader);
 	case ExtraTypeInfoType::USER_TYPE_INFO:
-		return UserTypeInfo::Deserialize(source);
+		return UserTypeInfo::Deserialize(reader);
 	case ExtraTypeInfoType::ENUM_TYPE_INFO: {
-		auto enum_size = source.Read<uint32_t>();
+		auto enum_size = reader.ReadRequired<uint32_t>();
 		auto enum_internal_type = EnumType::GetPhysicalType(enum_size);
 		switch (enum_internal_type) {
 		case PhysicalType::UINT8:
-			return EnumTypeInfoTemplated<uint8_t>::Deserialize(source, enum_size);
+			return EnumTypeInfoTemplated<uint8_t>::Deserialize(reader, enum_size);
 		case PhysicalType::UINT16:
-			return EnumTypeInfoTemplated<uint16_t>::Deserialize(source, enum_size);
+			return EnumTypeInfoTemplated<uint16_t>::Deserialize(reader, enum_size);
 		case PhysicalType::UINT32:
-			return EnumTypeInfoTemplated<uint32_t>::Deserialize(source, enum_size);
+			return EnumTypeInfoTemplated<uint32_t>::Deserialize(reader, enum_size);
 		default:
 			throw InternalException("Invalid Physical Type for ENUMs");
 		}
@@ -38681,13 +39033,18 @@ LogicalType::~LogicalType() {
 }
 
 void LogicalType::Serialize(Serializer &serializer) const {
-	serializer.Write<LogicalTypeId>(id_);
-	ExtraTypeInfo::Serialize(type_info_.get(), serializer);
+	FieldWriter writer(serializer);
+	writer.WriteField<LogicalTypeId>(id_);
+	ExtraTypeInfo::Serialize(type_info_.get(), writer);
+	writer.Finalize();
 }
 
 LogicalType LogicalType::Deserialize(Deserializer &source) {
-	auto id = source.Read<LogicalTypeId>();
-	auto info = ExtraTypeInfo::Deserialize(source);
+	FieldReader reader(source);
+	auto id = reader.ReadRequired<LogicalTypeId>();
+	auto info = ExtraTypeInfo::Deserialize(reader);
+	reader.Finalize();
+
 	return LogicalType(id, move(info));
 }
 
@@ -80324,14 +80681,14 @@ public:
 
 public:
 	void Merge(const BaseStatistics &other) override;
-	FilterPropagateResult CheckZonemap(ExpressionType comparison_type, const Value &constant);
+	FilterPropagateResult CheckZonemap(ExpressionType comparison_type, const Value &constant) const;
 
-	unique_ptr<BaseStatistics> Copy() override;
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<BaseStatistics> Deserialize(Deserializer &source, LogicalType type);
-	void Verify(Vector &vector, const SelectionVector &sel, idx_t count) override;
+	unique_ptr<BaseStatistics> Copy() const override;
+	void Serialize(FieldWriter &serializer) const override;
+	static unique_ptr<BaseStatistics> Deserialize(FieldReader &source, LogicalType type);
+	void Verify(Vector &vector, const SelectionVector &sel, idx_t count) const override;
 
-	string ToString() override;
+	string ToString() const override;
 };
 
 } // namespace duckdb
@@ -89142,14 +89499,14 @@ public:
 
 public:
 	void Merge(const BaseStatistics &other) override;
-	FilterPropagateResult CheckZonemap(ExpressionType comparison_type, const Value &constant);
+	FilterPropagateResult CheckZonemap(ExpressionType comparison_type, const Value &constant) const;
 
-	unique_ptr<BaseStatistics> Copy() override;
-	void Serialize(Serializer &serializer) override;
-	static unique_ptr<BaseStatistics> Deserialize(Deserializer &source, LogicalType type);
-	void Verify(Vector &vector, const SelectionVector &sel, idx_t count) override;
+	unique_ptr<BaseStatistics> Copy() const override;
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<BaseStatistics> Deserialize(FieldReader &reader, LogicalType type);
+	void Verify(Vector &vector, const SelectionVector &sel, idx_t count) const override;
 
-	string ToString() override;
+	string ToString() const override;
 };
 
 } // namespace duckdb
@@ -95682,12 +96039,14 @@ public:
 public:
 	bool Equals(const QueryNode *other) const override;
 	//! Create a copy of this SelectNode
-	unique_ptr<QueryNode> Copy() override;
-	//! Serializes a SelectNode to a stand-alone binary blob
-	void Serialize(Serializer &serializer) override;
-	//! Deserializes a blob back into a SelectNode
-	static unique_ptr<QueryNode> Deserialize(Deserializer &source);
+	unique_ptr<QueryNode> Copy() const override;
+
+	//! Serializes a QueryNode to a stand-alone binary blob
+	void Serialize(FieldWriter &writer) const override;
+	//! Deserializes a blob back into a QueryNode
+	static unique_ptr<QueryNode> Deserialize(FieldReader &reader);
 };
+
 } // namespace duckdb
 
 
@@ -99068,7 +99427,12 @@ unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatemen
 		auto copied_statement = statement->Copy();
 		if (statement->type == StatementType::SELECT_STATEMENT) {
 			// in case this is a select query, we verify the original statement
-			string error = VerifyQuery(lock, query, move(statement));
+			string error;
+			try {
+				error = VerifyQuery(lock, query, move(statement));
+			} catch (std::exception &ex) {
+				error = ex.what();
+			}
 			if (!error.empty()) {
 				// error in verifying query
 				return make_unique<PendingQueryResult>(error);
@@ -110612,12 +110976,12 @@ public:
 public:
 	bool Equals(const QueryNode *other) const override;
 	//! Create a copy of this SelectNode
-	unique_ptr<QueryNode> Copy() override;
+	unique_ptr<QueryNode> Copy() const override;
 
-	//! Serializes a SelectNode to a stand-alone binary blob
-	void Serialize(Serializer &serializer) override;
-	//! Deserializes a blob back into a SelectNode
-	static unique_ptr<QueryNode> Deserialize(Deserializer &source);
+	//! Serializes a QueryNode to a stand-alone binary blob
+	void Serialize(FieldWriter &writer) const override;
+	//! Deserializes a blob back into a QueryNode
+	static unique_ptr<QueryNode> Deserialize(FieldReader &reader);
 };
 
 } // namespace duckdb
@@ -127635,15 +127999,20 @@ ColumnDefinition ColumnDefinition::Copy() const {
 }
 
 void ColumnDefinition::Serialize(Serializer &serializer) const {
-	serializer.WriteString(name);
-	type.Serialize(serializer);
-	serializer.WriteOptional(default_value);
+	FieldWriter writer(serializer);
+	writer.WriteString(name);
+	writer.WriteSerializable(type);
+	writer.WriteOptional(default_value);
+	writer.Finalize();
 }
 
 ColumnDefinition ColumnDefinition::Deserialize(Deserializer &source) {
-	auto column_name = source.Read<string>();
-	auto column_type = LogicalType::Deserialize(source);
-	auto default_value = source.ReadOptional<ParsedExpression>();
+	FieldReader reader(source);
+	auto column_name = reader.ReadRequired<string>();
+	auto column_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
+	auto default_value = reader.ReadOptional<ParsedExpression>(nullptr);
+	reader.Finalize();
+
 	return ColumnDefinition(column_name, column_type, move(default_value));
 }
 
@@ -127654,6 +128023,7 @@ ColumnDefinition ColumnDefinition::Deserialize(Deserializer &source) {
 
 
 
+
 namespace duckdb {
 
 Constraint::Constraint(ConstraintType type) : type(type) {
@@ -127662,25 +128032,35 @@ Constraint::Constraint(ConstraintType type) : type(type) {
 Constraint::~Constraint() {
 }
 
-void Constraint::Serialize(Serializer &serializer) {
-	serializer.Write<ConstraintType>(type);
+void Constraint::Serialize(Serializer &serializer) const {
+	FieldWriter writer(serializer);
+	writer.WriteField<ConstraintType>(type);
+	Serialize(writer);
+	writer.Finalize();
 }
 
 unique_ptr<Constraint> Constraint::Deserialize(Deserializer &source) {
-	auto type = source.Read<ConstraintType>();
+	FieldReader reader(source);
+	auto type = reader.ReadRequired<ConstraintType>();
+	unique_ptr<Constraint> result;
 	switch (type) {
 	case ConstraintType::NOT_NULL:
-		return NotNullConstraint::Deserialize(source);
+		result = NotNullConstraint::Deserialize(reader);
+		break;
 	case ConstraintType::CHECK:
-		return CheckConstraint::Deserialize(source);
+		result = CheckConstraint::Deserialize(reader);
+		break;
 	case ConstraintType::UNIQUE:
-		return UniqueConstraint::Deserialize(source);
+		result = UniqueConstraint::Deserialize(reader);
+		break;
 	default:
 		throw InternalException("Unrecognized constraint type for serialization");
 	}
+	reader.Finalize();
+	return result;
 }
 
-void Constraint::Print() {
+void Constraint::Print() const {
 	Printer::Print(ToString());
 }
 
@@ -127699,17 +128079,16 @@ string CheckConstraint::ToString() const {
 	return "CHECK(" + expression->ToString() + ")";
 }
 
-unique_ptr<Constraint> CheckConstraint::Copy() {
+unique_ptr<Constraint> CheckConstraint::Copy() const {
 	return make_unique<CheckConstraint>(expression->Copy());
 }
 
-void CheckConstraint::Serialize(Serializer &serializer) {
-	Constraint::Serialize(serializer);
-	expression->Serialize(serializer);
+void CheckConstraint::Serialize(FieldWriter &writer) const {
+	writer.WriteSerializable(*expression);
 }
 
-unique_ptr<Constraint> CheckConstraint::Deserialize(Deserializer &source) {
-	auto expression = ParsedExpression::Deserialize(source);
+unique_ptr<Constraint> CheckConstraint::Deserialize(FieldReader &source) {
+	auto expression = source.ReadRequiredSerializable<ParsedExpression>();
 	return make_unique<CheckConstraint>(move(expression));
 }
 
@@ -127730,17 +128109,16 @@ string NotNullConstraint::ToString() const {
 	return "NOT NULL";
 }
 
-unique_ptr<Constraint> NotNullConstraint::Copy() {
+unique_ptr<Constraint> NotNullConstraint::Copy() const {
 	return make_unique<NotNullConstraint>(index);
 }
 
-void NotNullConstraint::Serialize(Serializer &serializer) {
-	Constraint::Serialize(serializer);
-	serializer.Write<idx_t>(index);
+void NotNullConstraint::Serialize(FieldWriter &writer) const {
+	writer.WriteField<idx_t>(index);
 }
 
-unique_ptr<Constraint> NotNullConstraint::Deserialize(Deserializer &source) {
-	auto index = source.Read<idx_t>();
+unique_ptr<Constraint> NotNullConstraint::Deserialize(FieldReader &source) {
+	auto index = source.ReadRequired<idx_t>();
 	return make_unique_base<Constraint, NotNullConstraint>(index);
 }
 
@@ -127772,7 +128150,7 @@ string UniqueConstraint::ToString() const {
 	return base + ")";
 }
 
-unique_ptr<Constraint> UniqueConstraint::Copy() {
+unique_ptr<Constraint> UniqueConstraint::Copy() const {
 	if (index == DConstants::INVALID_INDEX) {
 		return make_unique<UniqueConstraint>(columns, is_primary_key);
 	} else {
@@ -127782,26 +128160,17 @@ unique_ptr<Constraint> UniqueConstraint::Copy() {
 	}
 }
 
-void UniqueConstraint::Serialize(Serializer &serializer) {
-	Constraint::Serialize(serializer);
-	serializer.Write<bool>(is_primary_key);
-	serializer.Write<uint64_t>(index);
+void UniqueConstraint::Serialize(FieldWriter &writer) const {
+	writer.WriteField<bool>(is_primary_key);
+	writer.WriteField<uint64_t>(index);
 	D_ASSERT(columns.size() <= NumericLimits<uint32_t>::Maximum());
-	serializer.Write<uint32_t>((uint32_t)columns.size());
-	for (auto &column : columns) {
-		serializer.WriteString(column);
-	}
+	writer.WriteList<string>(columns);
 }
 
-unique_ptr<Constraint> UniqueConstraint::Deserialize(Deserializer &source) {
-	auto is_primary_key = source.Read<bool>();
-	auto index = source.Read<uint64_t>();
-	auto column_count = source.Read<uint32_t>();
-	vector<string> columns;
-	for (uint32_t i = 0; i < column_count; i++) {
-		auto column_name = source.Read<string>();
-		columns.push_back(column_name);
-	}
+unique_ptr<Constraint> UniqueConstraint::Deserialize(FieldReader &source) {
+	auto is_primary_key = source.ReadRequired<bool>();
+	auto index = source.ReadRequired<uint64_t>();
+	auto columns = source.ReadRequiredList<string>();
 
 	if (index != DConstants::INVALID_INDEX) {
 		// single column parsed constraint
@@ -127817,6 +128186,7 @@ unique_ptr<Constraint> UniqueConstraint::Deserialize(Deserializer &source) {
 } // namespace duckdb
 
 
+
 namespace duckdb {
 
 BetweenExpression::BetweenExpression(unique_ptr<ParsedExpression> input_p, unique_ptr<ParsedExpression> lower_p,
@@ -127848,17 +128218,16 @@ unique_ptr<ParsedExpression> BetweenExpression::Copy() const {
 	return move(copy);
 }
 
-void BetweenExpression::Serialize(Serializer &serializer) {
-	ParsedExpression::Serialize(serializer);
-	input->Serialize(serializer);
-	lower->Serialize(serializer);
-	upper->Serialize(serializer);
+void BetweenExpression::Serialize(FieldWriter &writer) const {
+	writer.WriteSerializable(*input);
+	writer.WriteSerializable(*lower);
+	writer.WriteSerializable(*upper);
 }
 
-unique_ptr<ParsedExpression> BetweenExpression::Deserialize(ExpressionType type, Deserializer &source) {
-	auto input = ParsedExpression::Deserialize(source);
-	auto lower = ParsedExpression::Deserialize(source);
-	auto upper = ParsedExpression::Deserialize(source);
+unique_ptr<ParsedExpression> BetweenExpression::Deserialize(ExpressionType type, FieldReader &source) {
+	auto input = source.ReadRequiredSerializable<ParsedExpression>();
+	auto lower = source.ReadRequiredSerializable<ParsedExpression>();
+	auto upper = source.ReadRequiredSerializable<ParsedExpression>();
 	return make_unique<BetweenExpression>(move(input), move(lower), move(upper));
 }
 
@@ -127913,26 +128282,29 @@ unique_ptr<ParsedExpression> CaseExpression::Copy() const {
 	return move(copy);
 }
 
-void CaseExpression::Serialize(Serializer &serializer) {
-	ParsedExpression::Serialize(serializer);
-	serializer.Write<uint32_t>(case_checks.size());
+void CaseExpression::Serialize(FieldWriter &writer) const {
+	auto &serializer = writer.GetSerializer();
+	// we write a list of multiple expressions here
+	// in order to write this as a single field we directly use the field writers' internal serializer
+	writer.WriteField<uint32_t>(case_checks.size());
 	for (auto &check : case_checks) {
 		check.when_expr->Serialize(serializer);
 		check.then_expr->Serialize(serializer);
 	}
-	else_expr->Serialize(serializer);
+	writer.WriteSerializable<ParsedExpression>(*else_expr);
 }
 
-unique_ptr<ParsedExpression> CaseExpression::Deserialize(ExpressionType type, Deserializer &source) {
+unique_ptr<ParsedExpression> CaseExpression::Deserialize(ExpressionType type, FieldReader &reader) {
 	auto result = make_unique<CaseExpression>();
-	auto count = source.Read<uint32_t>();
+	auto &source = reader.GetSource();
+	auto count = reader.ReadRequired<uint32_t>();
 	for (idx_t i = 0; i < count; i++) {
 		CaseCheck new_check;
 		new_check.when_expr = ParsedExpression::Deserialize(source);
 		new_check.then_expr = ParsedExpression::Deserialize(source);
 		result->case_checks.push_back(move(new_check));
 	}
-	result->else_expr = ParsedExpression::Deserialize(source);
+	result->else_expr = reader.ReadRequiredSerializable<ParsedExpression>();
 	return move(result);
 }
 
@@ -127974,17 +128346,16 @@ unique_ptr<ParsedExpression> CastExpression::Copy() const {
 	return move(copy);
 }
 
-void CastExpression::Serialize(Serializer &serializer) {
-	ParsedExpression::Serialize(serializer);
-	child->Serialize(serializer);
-	cast_type.Serialize(serializer);
-	serializer.Write<bool>(try_cast);
+void CastExpression::Serialize(FieldWriter &writer) const {
+	writer.WriteSerializable(*child);
+	writer.WriteSerializable(cast_type);
+	writer.WriteField<bool>(try_cast);
 }
 
-unique_ptr<ParsedExpression> CastExpression::Deserialize(ExpressionType type, Deserializer &source) {
-	auto child = ParsedExpression::Deserialize(source);
-	auto cast_type = LogicalType::Deserialize(source);
-	auto try_cast = source.Read<bool>();
+unique_ptr<ParsedExpression> CastExpression::Deserialize(ExpressionType type, FieldReader &reader) {
+	auto child = reader.ReadRequiredSerializable<ParsedExpression>();
+	auto cast_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
+	auto try_cast = reader.ReadRequired<bool>();
 	return make_unique_base<ParsedExpression, CastExpression>(cast_type, move(child), try_cast);
 }
 
@@ -128022,15 +128393,14 @@ unique_ptr<ParsedExpression> CollateExpression::Copy() const {
 	return move(copy);
 }
 
-void CollateExpression::Serialize(Serializer &serializer) {
-	ParsedExpression::Serialize(serializer);
-	child->Serialize(serializer);
-	serializer.WriteString(collation);
+void CollateExpression::Serialize(FieldWriter &writer) const {
+	writer.WriteSerializable(*child);
+	writer.WriteString(collation);
 }
 
-unique_ptr<ParsedExpression> CollateExpression::Deserialize(ExpressionType type, Deserializer &source) {
-	auto child = ParsedExpression::Deserialize(source);
-	auto collation = source.Read<string>();
+unique_ptr<ParsedExpression> CollateExpression::Deserialize(ExpressionType type, FieldReader &reader) {
+	auto child = reader.ReadRequiredSerializable<ParsedExpression>();
+	auto collation = reader.ReadRequired<string>();
 	return make_unique_base<ParsedExpression, CollateExpression>(collation, move(child));
 }
 
@@ -128041,7 +128411,6 @@ unique_ptr<ParsedExpression> CollateExpression::Deserialize(ExpressionType type,
 
 
 
-
 namespace duckdb {
 
 ColumnRefExpression::ColumnRefExpression(string column_name, string table_name)
@@ -128119,20 +128488,12 @@ unique_ptr<ParsedExpression> ColumnRefExpression::Copy() const {
 	return move(copy);
 }
 
-void ColumnRefExpression::Serialize(Serializer &serializer) {
-	ParsedExpression::Serialize(serializer);
-	serializer.Write<idx_t>(column_names.size());
-	for (auto &column_name : column_names) {
-		serializer.WriteString(column_name);
-	}
+void ColumnRefExpression::Serialize(FieldWriter &writer) const {
+	writer.WriteList<string>(column_names);
 }
 
-unique_ptr<ParsedExpression> ColumnRefExpression::Deserialize(ExpressionType type, Deserializer &source) {
-	auto column_count = source.Read<idx_t>();
-	vector<string> column_names;
-	for (idx_t i = 0; i < column_count; i++) {
-		column_names.push_back(source.Read<string>());
-	}
+unique_ptr<ParsedExpression> ColumnRefExpression::Deserialize(ExpressionType type, FieldReader &reader) {
+	auto column_names = reader.ReadRequiredList<string>();
 	auto expression = make_unique<ColumnRefExpression>(move(column_names));
 	return move(expression);
 }
@@ -128173,15 +128534,14 @@ unique_ptr<ParsedExpression> ComparisonExpression::Copy() const {
 	return move(copy);
 }
 
-void ComparisonExpression::Serialize(Serializer &serializer) {
-	ParsedExpression::Serialize(serializer);
-	left->Serialize(serializer);
-	right->Serialize(serializer);
+void ComparisonExpression::Serialize(FieldWriter &writer) const {
+	writer.WriteSerializable(*left);
+	writer.WriteSerializable(*right);
 }
 
-unique_ptr<ParsedExpression> ComparisonExpression::Deserialize(ExpressionType type, Deserializer &source) {
-	auto left_child = ParsedExpression::Deserialize(source);
-	auto right_child = ParsedExpression::Deserialize(source);
+unique_ptr<ParsedExpression> ComparisonExpression::Deserialize(ExpressionType type, FieldReader &reader) {
+	auto left_child = reader.ReadRequiredSerializable<ParsedExpression>();
+	auto right_child = reader.ReadRequiredSerializable<ParsedExpression>();
 	return make_unique<ComparisonExpression>(type, move(left_child), move(right_child));
 }
 
@@ -128280,14 +128640,13 @@ unique_ptr<ParsedExpression> ConjunctionExpression::Copy() const {
 	return move(copy);
 }
 
-void ConjunctionExpression::Serialize(Serializer &serializer) {
-	ParsedExpression::Serialize(serializer);
-	serializer.WriteList<ParsedExpression>(children);
+void ConjunctionExpression::Serialize(FieldWriter &writer) const {
+	writer.WriteSerializableList(children);
 }
 
-unique_ptr<ParsedExpression> ConjunctionExpression::Deserialize(ExpressionType type, Deserializer &source) {
+unique_ptr<ParsedExpression> ConjunctionExpression::Deserialize(ExpressionType type, FieldReader &reader) {
 	auto result = make_unique<ConjunctionExpression>(type);
-	source.ReadList<ParsedExpression>(result->children);
+	result->children = reader.ReadRequiredSerializableList<ParsedExpression>();
 	return move(result);
 }
 
@@ -128298,6 +128657,7 @@ unique_ptr<ParsedExpression> ConjunctionExpression::Deserialize(ExpressionType t
 
 
 
+
 namespace duckdb {
 
 ConstantExpression::ConstantExpression(Value val)
@@ -128322,13 +128682,12 @@ unique_ptr<ParsedExpression> ConstantExpression::Copy() const {
 	return move(copy);
 }
 
-void ConstantExpression::Serialize(Serializer &serializer) {
-	ParsedExpression::Serialize(serializer);
-	value.Serialize(serializer);
+void ConstantExpression::Serialize(FieldWriter &writer) const {
+	writer.WriteSerializable(value);
 }
 
-unique_ptr<ParsedExpression> ConstantExpression::Deserialize(ExpressionType type, Deserializer &source) {
-	Value value = Value::Deserialize(source);
+unique_ptr<ParsedExpression> ConstantExpression::Deserialize(ExpressionType type, FieldReader &reader) {
+	Value value = reader.ReadRequiredSerializable<Value, Value>();
 	return make_unique<ConstantExpression>(move(value));
 }
 
@@ -128352,7 +128711,10 @@ unique_ptr<ParsedExpression> DefaultExpression::Copy() const {
 	return move(copy);
 }
 
-unique_ptr<ParsedExpression> DefaultExpression::Deserialize(ExpressionType type, Deserializer &source) {
+void DefaultExpression::Serialize(FieldWriter &writer) const {
+}
+
+unique_ptr<ParsedExpression> DefaultExpression::Deserialize(ExpressionType type, FieldReader &source) {
 	return make_unique<DefaultExpression>();
 }
 
@@ -128466,26 +128828,24 @@ unique_ptr<ParsedExpression> FunctionExpression::Copy() const {
 	return move(copy);
 }
 
-void FunctionExpression::Serialize(Serializer &serializer) {
-	ParsedExpression::Serialize(serializer);
-	serializer.WriteString(function_name);
-	serializer.WriteString(schema);
-	serializer.WriteList(children);
-	serializer.WriteOptional(filter);
-	order_bys->Serialize(serializer);
-	serializer.Write<bool>(distinct);
-	serializer.Write<bool>(is_operator);
-}
-
-unique_ptr<ParsedExpression> FunctionExpression::Deserialize(ExpressionType type, Deserializer &source) {
-	vector<unique_ptr<ParsedExpression>> children;
-	auto function_name = source.Read<string>();
-	auto schema = source.Read<string>();
-	source.ReadList<ParsedExpression>(children);
-	auto filter = source.ReadOptional<ParsedExpression>();
-	unique_ptr<OrderModifier> order_bys(static_cast<OrderModifier *>(ResultModifier::Deserialize(source).release()));
-	auto distinct = source.Read<bool>();
-	auto is_operator = source.Read<bool>();
+void FunctionExpression::Serialize(FieldWriter &writer) const {
+	writer.WriteString(function_name);
+	writer.WriteString(schema);
+	writer.WriteSerializableList(children);
+	writer.WriteOptional(filter);
+	writer.WriteSerializable((ResultModifier &)*order_bys);
+	writer.WriteField<bool>(distinct);
+	writer.WriteField<bool>(is_operator);
+}
+
+unique_ptr<ParsedExpression> FunctionExpression::Deserialize(ExpressionType type, FieldReader &reader) {
+	auto function_name = reader.ReadRequired<string>();
+	auto schema = reader.ReadRequired<string>();
+	auto children = reader.ReadRequiredSerializableList<ParsedExpression>();
+	auto filter = reader.ReadOptional<ParsedExpression>(nullptr);
+	auto order_bys = unique_ptr_cast<ResultModifier, OrderModifier>(reader.ReadRequiredSerializable<ResultModifier>());
+	auto distinct = reader.ReadRequired<bool>();
+	auto is_operator = reader.ReadRequired<bool>();
 	unique_ptr<FunctionExpression> function;
 	function = make_unique<FunctionExpression>(function_name, move(children), move(filter), move(order_bys), distinct,
 	                                           is_operator);
@@ -128498,7 +128858,6 @@ unique_ptr<ParsedExpression> FunctionExpression::Deserialize(ExpressionType type
 
 
 
-
 namespace duckdb {
 
 LambdaExpression::LambdaExpression(vector<string> parameters, unique_ptr<ParsedExpression> expression)
@@ -128545,24 +128904,14 @@ unique_ptr<ParsedExpression> LambdaExpression::Copy() const {
 	return make_unique<LambdaExpression>(parameters, expression->Copy());
 }
 
-void LambdaExpression::Serialize(Serializer &serializer) {
-	ParsedExpression::Serialize(serializer);
-	serializer.Write<uint32_t>(parameters.size());
-	for (auto &parameter : parameters) {
-		serializer.WriteString(parameter);
-	}
-	expression->Serialize(serializer);
+void LambdaExpression::Serialize(FieldWriter &writer) const {
+	writer.WriteList<string>(parameters);
+	writer.WriteSerializable(*expression);
 }
 
-unique_ptr<ParsedExpression> LambdaExpression::Deserialize(ExpressionType type, Deserializer &source) {
-	auto parameter_count = source.Read<uint32_t>();
-	vector<string> parameters;
-	parameters.reserve(parameter_count);
-	for (size_t i = 0; i < parameter_count; i++) {
-		parameters.push_back(source.Read<string>());
-	}
-	auto expression = ParsedExpression::Deserialize(source);
-
+unique_ptr<ParsedExpression> LambdaExpression::Deserialize(ExpressionType type, FieldReader &reader) {
+	auto parameters = reader.ReadRequiredList<string>();
+	auto expression = reader.ReadRequiredSerializable<ParsedExpression>();
 	return make_unique<LambdaExpression>(move(parameters), move(expression));
 }
 
@@ -128629,14 +128978,13 @@ unique_ptr<ParsedExpression> OperatorExpression::Copy() const {
 	return move(copy);
 }
 
-void OperatorExpression::Serialize(Serializer &serializer) {
-	ParsedExpression::Serialize(serializer);
-	serializer.WriteList(children);
+void OperatorExpression::Serialize(FieldWriter &writer) const {
+	writer.WriteSerializableList(children);
 }
 
-unique_ptr<ParsedExpression> OperatorExpression::Deserialize(ExpressionType type, Deserializer &source) {
+unique_ptr<ParsedExpression> OperatorExpression::Deserialize(ExpressionType type, FieldReader &reader) {
 	auto expression = make_unique<OperatorExpression>(type);
-	source.ReadList<ParsedExpression>(expression->children);
+	expression->children = reader.ReadRequiredSerializableList<ParsedExpression>();
 	return move(expression);
 }
 
@@ -128670,14 +129018,13 @@ hash_t ParameterExpression::Hash() const {
 	return CombineHash(duckdb::Hash(parameter_nr), result);
 }
 
-void ParameterExpression::Serialize(Serializer &serializer) {
-	ParsedExpression::Serialize(serializer);
-	serializer.Write<idx_t>(parameter_nr);
+void ParameterExpression::Serialize(FieldWriter &writer) const {
+	writer.WriteField<idx_t>(parameter_nr);
 }
 
-unique_ptr<ParsedExpression> ParameterExpression::Deserialize(ExpressionType type, Deserializer &source) {
+unique_ptr<ParsedExpression> ParameterExpression::Deserialize(ExpressionType type, FieldReader &reader) {
 	auto expression = make_unique<ParameterExpression>();
-	expression->parameter_nr = source.Read<idx_t>();
+	expression->parameter_nr = reader.ReadRequired<idx_t>();
 	return move(expression);
 }
 
@@ -128715,13 +129062,12 @@ hash_t PositionalReferenceExpression::Hash() const {
 	return CombineHash(duckdb::Hash(index), result);
 }
 
-void PositionalReferenceExpression::Serialize(Serializer &serializer) {
-	ParsedExpression::Serialize(serializer);
-	serializer.Write<idx_t>(index);
+void PositionalReferenceExpression::Serialize(FieldWriter &writer) const {
+	writer.WriteField<idx_t>(index);
 }
 
-unique_ptr<ParsedExpression> PositionalReferenceExpression::Deserialize(ExpressionType type, Deserializer &source) {
-	auto expression = make_unique<PositionalReferenceExpression>(source.Read<idx_t>());
+unique_ptr<ParsedExpression> PositionalReferenceExpression::Deserialize(ExpressionType type, FieldReader &reader) {
+	auto expression = make_unique<PositionalReferenceExpression>(reader.ReadRequired<idx_t>());
 	return move(expression);
 }
 
@@ -128787,28 +129133,34 @@ bool StarExpression::Equals(const StarExpression *a, const StarExpression *b) {
 	return true;
 }
 
-void StarExpression::Serialize(Serializer &serializer) {
-	ParsedExpression::Serialize(serializer);
-	serializer.WriteString(relation_name);
-	serializer.Write<uint32_t>(exclude_list.size());
+void StarExpression::Serialize(FieldWriter &writer) const {
+	auto &serializer = writer.GetSerializer();
+
+	writer.WriteString(relation_name);
+
+	// in order to write the exclude_list/replace_list as single fields we directly use the field writers' internal
+	// serializer
+	writer.WriteField<uint32_t>(exclude_list.size());
 	for (auto &exclusion : exclude_list) {
 		serializer.WriteString(exclusion);
 	}
-	serializer.Write<uint32_t>(replace_list.size());
+	writer.WriteField<uint32_t>(replace_list.size());
 	for (auto &entry : replace_list) {
 		serializer.WriteString(entry.first);
 		entry.second->Serialize(serializer);
 	}
 }
 
-unique_ptr<ParsedExpression> StarExpression::Deserialize(ExpressionType type, Deserializer &source) {
+unique_ptr<ParsedExpression> StarExpression::Deserialize(ExpressionType type, FieldReader &reader) {
+	auto &source = reader.GetSource();
+
 	auto result = make_unique<StarExpression>();
-	result->relation_name = source.Read<string>();
-	auto exclusion_count = source.Read<uint32_t>();
+	result->relation_name = reader.ReadRequired<string>();
+	auto exclusion_count = reader.ReadRequired<uint32_t>();
 	for (idx_t i = 0; i < exclusion_count; i++) {
 		result->exclude_list.insert(source.Read<string>());
 	}
-	auto replace_count = source.Read<uint32_t>();
+	auto replace_count = reader.ReadRequired<uint32_t>();
 	for (idx_t i = 0; i < replace_count; i++) {
 		auto name = source.Read<string>();
 		auto expr = ParsedExpression::Deserialize(source);
@@ -128865,23 +129217,28 @@ unique_ptr<ParsedExpression> SubqueryExpression::Copy() const {
 	return move(copy);
 }
 
-void SubqueryExpression::Serialize(Serializer &serializer) {
-	ParsedExpression::Serialize(serializer);
-	serializer.Write<SubqueryType>(subquery_type);
+void SubqueryExpression::Serialize(FieldWriter &writer) const {
+	auto &serializer = writer.GetSerializer();
+
+	writer.WriteField<SubqueryType>(subquery_type);
+	// FIXME: this shouldn't use a serializer (probably)?
 	subquery->Serialize(serializer);
-	serializer.WriteOptional(child);
-	serializer.Write<ExpressionType>(comparison_type);
+	writer.WriteOptional(child);
+	writer.WriteField<ExpressionType>(comparison_type);
 }
 
-unique_ptr<ParsedExpression> SubqueryExpression::Deserialize(ExpressionType type, Deserializer &source) {
-	auto subquery_type = source.Read<SubqueryType>();
+unique_ptr<ParsedExpression> SubqueryExpression::Deserialize(ExpressionType type, FieldReader &reader) {
+	// FIXME: this shouldn't use a source
+	auto &source = reader.GetSource();
+
+	auto subquery_type = reader.ReadRequired<SubqueryType>();
 	auto subquery = SelectStatement::Deserialize(source);
 
 	auto expression = make_unique<SubqueryExpression>();
 	expression->subquery_type = subquery_type;
 	expression->subquery = move(subquery);
-	expression->child = source.ReadOptional<ParsedExpression>();
-	expression->comparison_type = source.Read<ExpressionType>();
+	expression->child = reader.ReadOptional<ParsedExpression>(nullptr);
+	expression->comparison_type = reader.ReadRequired<ExpressionType>();
 	return move(expression);
 }
 
@@ -129112,46 +129469,49 @@ unique_ptr<ParsedExpression> WindowExpression::Copy() const {
 	return move(new_window);
 }
 
-void WindowExpression::Serialize(Serializer &serializer) {
-	ParsedExpression::Serialize(serializer);
-	serializer.WriteString(function_name);
-	serializer.WriteString(schema);
-	serializer.WriteList(children);
-	serializer.WriteList(partitions);
+void WindowExpression::Serialize(FieldWriter &writer) const {
+	auto &serializer = writer.GetSerializer();
+
+	writer.WriteString(function_name);
+	writer.WriteString(schema);
+	writer.WriteSerializableList(children);
+	writer.WriteSerializableList(partitions);
+	// FIXME: should not use serializer here (probably)?
 	D_ASSERT(orders.size() <= NumericLimits<uint32_t>::Maximum());
-	serializer.Write<uint32_t>((uint32_t)orders.size());
+	writer.WriteField<uint32_t>((uint32_t)orders.size());
 	for (auto &order : orders) {
 		order.Serialize(serializer);
 	}
-	serializer.Write<WindowBoundary>(start);
-	serializer.Write<WindowBoundary>(end);
+	writer.WriteField<WindowBoundary>(start);
+	writer.WriteField<WindowBoundary>(end);
 
-	serializer.WriteOptional(start_expr);
-	serializer.WriteOptional(end_expr);
-	serializer.WriteOptional(offset_expr);
-	serializer.WriteOptional(default_expr);
-	serializer.Write<bool>(ignore_nulls);
+	writer.WriteOptional(start_expr);
+	writer.WriteOptional(end_expr);
+	writer.WriteOptional(offset_expr);
+	writer.WriteOptional(default_expr);
+	writer.WriteField<bool>(ignore_nulls);
 }
 
-unique_ptr<ParsedExpression> WindowExpression::Deserialize(ExpressionType type, Deserializer &source) {
-	auto function_name = source.Read<string>();
-	auto schema = source.Read<string>();
+unique_ptr<ParsedExpression> WindowExpression::Deserialize(ExpressionType type, FieldReader &reader) {
+	auto function_name = reader.ReadRequired<string>();
+	auto schema = reader.ReadRequired<string>();
 	auto expr = make_unique<WindowExpression>(type, schema, function_name);
-	source.ReadList<ParsedExpression>(expr->children);
-	source.ReadList<ParsedExpression>(expr->partitions);
+	expr->children = reader.ReadRequiredSerializableList<ParsedExpression>();
+	expr->partitions = reader.ReadRequiredSerializableList<ParsedExpression>();
 
-	auto order_count = source.Read<uint32_t>();
+	auto order_count = reader.ReadRequired<uint32_t>();
+	auto &source = reader.GetSource();
 	for (idx_t i = 0; i < order_count; i++) {
 		expr->orders.push_back(OrderByNode::Deserialize((source)));
 	}
-	expr->start = source.Read<WindowBoundary>();
-	expr->end = source.Read<WindowBoundary>();
+	expr->start = reader.ReadRequired<WindowBoundary>();
+	expr->end = reader.ReadRequired<WindowBoundary>();
 
-	expr->start_expr = source.ReadOptional<ParsedExpression>();
-	expr->end_expr = source.ReadOptional<ParsedExpression>();
-	expr->offset_expr = source.ReadOptional<ParsedExpression>();
-	expr->default_expr = source.ReadOptional<ParsedExpression>();
-	expr->ignore_nulls = source.Read<bool>();
+	expr->start_expr = reader.ReadOptional<ParsedExpression>(nullptr);
+	expr->end_expr = reader.ReadOptional<ParsedExpression>(nullptr);
+	expr->offset_expr = reader.ReadOptional<ParsedExpression>(nullptr);
+	expr->default_expr = reader.ReadOptional<ParsedExpression>(nullptr);
+	expr->ignore_nulls = reader.ReadRequired<bool>();
 	return move(expr);
 }
 
@@ -129266,27 +129626,50 @@ string KeywordHelper::WriteOptionallyQuoted(const string &text) {
 
 namespace duckdb {
 
-void AlterInfo::Serialize(Serializer &serializer) {
-	serializer.Write<AlterType>(type);
+AlterInfo::AlterInfo(AlterType type, string schema_p, string name_p)
+    : type(type), schema(move(schema_p)), name(move(name_p)) {
+}
+
+AlterInfo::~AlterInfo() {
+}
+
+void AlterInfo::Serialize(Serializer &serializer) const {
+	FieldWriter writer(serializer);
+	writer.WriteField<AlterType>(type);
+	Serialize(writer);
+	writer.Finalize();
 }
 
 unique_ptr<AlterInfo> AlterInfo::Deserialize(Deserializer &source) {
-	auto type = source.Read<AlterType>();
+	FieldReader reader(source);
+	auto type = reader.ReadRequired<AlterType>();
+
+	unique_ptr<AlterInfo> result;
 	switch (type) {
 	case AlterType::ALTER_TABLE:
-		return AlterTableInfo::Deserialize(source);
+		result = AlterTableInfo::Deserialize(reader);
+		break;
 	case AlterType::ALTER_VIEW:
-		return AlterViewInfo::Deserialize(source);
+		result = AlterViewInfo::Deserialize(reader);
+		break;
 	default:
 		throw SerializationException("Unknown alter type for deserialization!");
 	}
+	reader.Finalize();
+
+	return result;
 }
 
 //===--------------------------------------------------------------------===//
 // ChangeOwnershipInfo
 //===--------------------------------------------------------------------===//
+ChangeOwnershipInfo::ChangeOwnershipInfo(CatalogType entry_catalog_type, string entry_schema_p, string entry_name_p,
+                                         string owner_schema_p, string owner_name_p)
+    : AlterInfo(AlterType::CHANGE_OWNERSHIP, move(entry_schema_p), move(entry_name_p)),
+      entry_catalog_type(entry_catalog_type), owner_schema(move(owner_schema_p)), owner_name(move(owner_name_p)) {
+}
 
-CatalogType ChangeOwnershipInfo::GetCatalogType() {
+CatalogType ChangeOwnershipInfo::GetCatalogType() const {
 	return entry_catalog_type;
 }
 
@@ -129294,35 +129677,48 @@ unique_ptr<AlterInfo> ChangeOwnershipInfo::Copy() const {
 	return make_unique_base<AlterInfo, ChangeOwnershipInfo>(entry_catalog_type, schema, name, owner_schema, owner_name);
 }
 
+void ChangeOwnershipInfo::Serialize(FieldWriter &writer) const {
+	throw InternalException("ChangeOwnershipInfo cannot be serialized");
+}
+
 //===--------------------------------------------------------------------===//
 // AlterTableInfo
 //===--------------------------------------------------------------------===//
+AlterTableInfo::AlterTableInfo(AlterTableType type, string schema_p, string table_p)
+    : AlterInfo(AlterType::ALTER_TABLE, move(move(schema_p)), move(table_p)), alter_table_type(type) {
+}
+AlterTableInfo::~AlterTableInfo() {
+}
 
-void AlterTableInfo::Serialize(Serializer &serializer) {
-	AlterInfo::Serialize(serializer);
-	serializer.Write<AlterTableType>(alter_table_type);
-	serializer.WriteString(schema);
-	serializer.WriteString(name);
+CatalogType AlterTableInfo::GetCatalogType() const {
+	return CatalogType::TABLE_ENTRY;
 }
 
-unique_ptr<AlterInfo> AlterTableInfo::Deserialize(Deserializer &source) {
-	auto type = source.Read<AlterTableType>();
-	auto schema = source.Read<string>();
-	auto table = source.Read<string>();
+void AlterTableInfo::Serialize(FieldWriter &writer) const {
+	writer.WriteField<AlterTableType>(alter_table_type);
+	writer.WriteString(schema);
+	writer.WriteString(name);
+	SerializeAlterTable(writer);
+}
+
+unique_ptr<AlterInfo> AlterTableInfo::Deserialize(FieldReader &reader) {
+	auto type = reader.ReadRequired<AlterTableType>();
+	auto schema = reader.ReadRequired<string>();
+	auto table = reader.ReadRequired<string>();
 	unique_ptr<AlterTableInfo> info;
 	switch (type) {
 	case AlterTableType::RENAME_COLUMN:
-		return RenameColumnInfo::Deserialize(source, schema, table);
+		return RenameColumnInfo::Deserialize(reader, schema, table);
 	case AlterTableType::RENAME_TABLE:
-		return RenameTableInfo::Deserialize(source, schema, table);
+		return RenameTableInfo::Deserialize(reader, schema, table);
 	case AlterTableType::ADD_COLUMN:
-		return AddColumnInfo::Deserialize(source, schema, table);
+		return AddColumnInfo::Deserialize(reader, schema, table);
 	case AlterTableType::REMOVE_COLUMN:
-		return RemoveColumnInfo::Deserialize(source, schema, table);
+		return RemoveColumnInfo::Deserialize(reader, schema, table);
 	case AlterTableType::ALTER_COLUMN_TYPE:
-		return ChangeColumnTypeInfo::Deserialize(source, schema, table);
+		return ChangeColumnTypeInfo::Deserialize(reader, schema, table);
 	case AlterTableType::SET_DEFAULT:
-		return SetDefaultInfo::Deserialize(source, schema, table);
+		return SetDefaultInfo::Deserialize(reader, schema, table);
 	default:
 		throw SerializationException("Unknown alter table type for deserialization!");
 	}
@@ -129331,94 +129727,123 @@ unique_ptr<AlterInfo> AlterTableInfo::Deserialize(Deserializer &source) {
 //===--------------------------------------------------------------------===//
 // RenameColumnInfo
 //===--------------------------------------------------------------------===//
+RenameColumnInfo::RenameColumnInfo(string schema_p, string table_p, string old_name_p, string new_name_p)
+    : AlterTableInfo(AlterTableType::RENAME_COLUMN, move(schema_p), move(table_p)), old_name(move(old_name_p)),
+      new_name(move(new_name_p)) {
+}
+RenameColumnInfo::~RenameColumnInfo() {
+}
+
 unique_ptr<AlterInfo> RenameColumnInfo::Copy() const {
 	return make_unique_base<AlterInfo, RenameColumnInfo>(schema, name, old_name, new_name);
 }
 
-void RenameColumnInfo::Serialize(Serializer &serializer) {
-	AlterTableInfo::Serialize(serializer);
-	serializer.WriteString(old_name);
-	serializer.WriteString(new_name);
+void RenameColumnInfo::SerializeAlterTable(FieldWriter &writer) const {
+	writer.WriteString(old_name);
+	writer.WriteString(new_name);
 }
 
-unique_ptr<AlterInfo> RenameColumnInfo::Deserialize(Deserializer &source, string schema, string table) {
-	auto old_name = source.Read<string>();
-	auto new_name = source.Read<string>();
+unique_ptr<AlterInfo> RenameColumnInfo::Deserialize(FieldReader &reader, string schema, string table) {
+	auto old_name = reader.ReadRequired<string>();
+	auto new_name = reader.ReadRequired<string>();
 	return make_unique<RenameColumnInfo>(move(schema), move(table), old_name, new_name);
 }
 
 //===--------------------------------------------------------------------===//
 // RenameTableInfo
 //===--------------------------------------------------------------------===//
+RenameTableInfo::RenameTableInfo(string schema_p, string table_p, string new_name_p)
+    : AlterTableInfo(AlterTableType::RENAME_TABLE, move(schema_p), move(table_p)), new_table_name(move(new_name_p)) {
+}
+RenameTableInfo::~RenameTableInfo() {
+}
+
 unique_ptr<AlterInfo> RenameTableInfo::Copy() const {
 	return make_unique_base<AlterInfo, RenameTableInfo>(schema, name, new_table_name);
 }
 
-void RenameTableInfo::Serialize(Serializer &serializer) {
-	AlterTableInfo::Serialize(serializer);
-	serializer.WriteString(new_table_name);
+void RenameTableInfo::SerializeAlterTable(FieldWriter &writer) const {
+	writer.WriteString(new_table_name);
 }
 
-unique_ptr<AlterInfo> RenameTableInfo::Deserialize(Deserializer &source, string schema, string table) {
-	auto new_name = source.Read<string>();
+unique_ptr<AlterInfo> RenameTableInfo::Deserialize(FieldReader &reader, string schema, string table) {
+	auto new_name = reader.ReadRequired<string>();
 	return make_unique<RenameTableInfo>(move(schema), move(table), new_name);
 }
 
 //===--------------------------------------------------------------------===//
 // AddColumnInfo
 //===--------------------------------------------------------------------===//
+AddColumnInfo::AddColumnInfo(string schema_p, string table_p, ColumnDefinition new_column)
+    : AlterTableInfo(AlterTableType::ADD_COLUMN, move(schema_p), move(table_p)), new_column(move(new_column)) {
+}
+AddColumnInfo::~AddColumnInfo() {
+}
+
 unique_ptr<AlterInfo> AddColumnInfo::Copy() const {
 	return make_unique_base<AlterInfo, AddColumnInfo>(schema, name, new_column.Copy());
 }
 
-void AddColumnInfo::Serialize(Serializer &serializer) {
-	AlterTableInfo::Serialize(serializer);
-	new_column.Serialize(serializer);
+void AddColumnInfo::SerializeAlterTable(FieldWriter &writer) const {
+	writer.WriteSerializable(new_column);
 }
 
-unique_ptr<AlterInfo> AddColumnInfo::Deserialize(Deserializer &source, string schema, string table) {
-	auto new_column = ColumnDefinition::Deserialize(source);
+unique_ptr<AlterInfo> AddColumnInfo::Deserialize(FieldReader &reader, string schema, string table) {
+	auto new_column = reader.ReadRequiredSerializable<ColumnDefinition, ColumnDefinition>();
 	return make_unique<AddColumnInfo>(move(schema), move(table), move(new_column));
 }
 
 //===--------------------------------------------------------------------===//
 // RemoveColumnInfo
 //===--------------------------------------------------------------------===//
+RemoveColumnInfo::RemoveColumnInfo(string schema_p, string table_p, string removed_column, bool if_exists)
+    : AlterTableInfo(AlterTableType::REMOVE_COLUMN, move(schema_p), move(table_p)),
+      removed_column(move(removed_column)), if_exists(if_exists) {
+}
+RemoveColumnInfo::~RemoveColumnInfo() {
+}
+
 unique_ptr<AlterInfo> RemoveColumnInfo::Copy() const {
 	return make_unique_base<AlterInfo, RemoveColumnInfo>(schema, name, removed_column, if_exists);
 }
 
-void RemoveColumnInfo::Serialize(Serializer &serializer) {
-	AlterTableInfo::Serialize(serializer);
-	serializer.WriteString(removed_column);
-	serializer.Write<bool>(if_exists);
+void RemoveColumnInfo::SerializeAlterTable(FieldWriter &writer) const {
+	writer.WriteString(removed_column);
+	writer.WriteField<bool>(if_exists);
 }
 
-unique_ptr<AlterInfo> RemoveColumnInfo::Deserialize(Deserializer &source, string schema, string table) {
-	auto new_name = source.Read<string>();
-	auto if_exists = source.Read<bool>();
+unique_ptr<AlterInfo> RemoveColumnInfo::Deserialize(FieldReader &reader, string schema, string table) {
+	auto new_name = reader.ReadRequired<string>();
+	auto if_exists = reader.ReadRequired<bool>();
 	return make_unique<RemoveColumnInfo>(move(schema), move(table), new_name, if_exists);
 }
 
 //===--------------------------------------------------------------------===//
 // ChangeColumnTypeInfo
 //===--------------------------------------------------------------------===//
+ChangeColumnTypeInfo::ChangeColumnTypeInfo(string schema_p, string table_p, string column_name, LogicalType target_type,
+                                           unique_ptr<ParsedExpression> expression)
+    : AlterTableInfo(AlterTableType::ALTER_COLUMN_TYPE, move(schema_p), move(table_p)), column_name(move(column_name)),
+      target_type(move(target_type)), expression(move(expression)) {
+}
+ChangeColumnTypeInfo::~ChangeColumnTypeInfo() {
+}
+
 unique_ptr<AlterInfo> ChangeColumnTypeInfo::Copy() const {
 	return make_unique_base<AlterInfo, ChangeColumnTypeInfo>(schema, name, column_name, target_type,
 	                                                         expression->Copy());
 }
 
-void ChangeColumnTypeInfo::Serialize(Serializer &serializer) {
-	AlterTableInfo::Serialize(serializer);
-	serializer.WriteString(column_name);
-	target_type.Serialize(serializer);
-	serializer.WriteOptional(expression);
+void ChangeColumnTypeInfo::SerializeAlterTable(FieldWriter &writer) const {
+	writer.WriteString(column_name);
+	writer.WriteSerializable(target_type);
+	writer.WriteOptional(expression);
 }
 
-unique_ptr<AlterInfo> ChangeColumnTypeInfo::Deserialize(Deserializer &source, string schema, string table) {
-	auto column_name = source.Read<string>();
-	auto target_type = LogicalType::Deserialize(source);
-	auto expression = source.ReadOptional<ParsedExpression>();
+unique_ptr<AlterInfo> ChangeColumnTypeInfo::Deserialize(FieldReader &reader, string schema, string table) {
+	auto column_name = reader.ReadRequired<string>();
+	auto target_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
+	auto expression = reader.ReadOptional<ParsedExpression>(nullptr);
 	return make_unique<ChangeColumnTypeInfo>(move(schema), move(table), move(column_name), move(target_type),
 	                                         move(expression));
 }
@@ -129426,41 +129851,58 @@ unique_ptr<AlterInfo> ChangeColumnTypeInfo::Deserialize(Deserializer &source, st
 //===--------------------------------------------------------------------===//
 // SetDefaultInfo
 //===--------------------------------------------------------------------===//
+SetDefaultInfo::SetDefaultInfo(string schema_p, string table_p, string column_name_p,
+                               unique_ptr<ParsedExpression> new_default)
+    : AlterTableInfo(AlterTableType::SET_DEFAULT, move(schema_p), move(table_p)), column_name(move(column_name_p)),
+      expression(move(new_default)) {
+}
+SetDefaultInfo::~SetDefaultInfo() {
+}
+
 unique_ptr<AlterInfo> SetDefaultInfo::Copy() const {
 	return make_unique_base<AlterInfo, SetDefaultInfo>(schema, name, column_name,
 	                                                   expression ? expression->Copy() : nullptr);
 }
 
-void SetDefaultInfo::Serialize(Serializer &serializer) {
-	AlterTableInfo::Serialize(serializer);
-	serializer.WriteString(column_name);
-	serializer.WriteOptional(expression);
+void SetDefaultInfo::SerializeAlterTable(FieldWriter &writer) const {
+	writer.WriteString(column_name);
+	writer.WriteOptional(expression);
 }
 
-unique_ptr<AlterInfo> SetDefaultInfo::Deserialize(Deserializer &source, string schema, string table) {
-	auto column_name = source.Read<string>();
-	auto new_default = source.ReadOptional<ParsedExpression>();
+unique_ptr<AlterInfo> SetDefaultInfo::Deserialize(FieldReader &reader, string schema, string table) {
+	auto column_name = reader.ReadRequired<string>();
+	auto new_default = reader.ReadOptional<ParsedExpression>(nullptr);
 	return make_unique<SetDefaultInfo>(move(schema), move(table), move(column_name), move(new_default));
 }
 
 //===--------------------------------------------------------------------===//
 // Alter View
 //===--------------------------------------------------------------------===//
-void AlterViewInfo::Serialize(Serializer &serializer) {
-	AlterInfo::Serialize(serializer);
-	serializer.Write<AlterViewType>(alter_view_type);
-	serializer.WriteString(schema);
-	serializer.WriteString(name);
+AlterViewInfo::AlterViewInfo(AlterViewType type, string schema_p, string view_p)
+    : AlterInfo(AlterType::ALTER_VIEW, move(schema_p), move(view_p)), alter_view_type(type) {
+}
+AlterViewInfo::~AlterViewInfo() {
 }
 
-unique_ptr<AlterInfo> AlterViewInfo::Deserialize(Deserializer &source) {
-	auto type = source.Read<AlterViewType>();
-	auto schema = source.Read<string>();
-	auto view = source.Read<string>();
+CatalogType AlterViewInfo::GetCatalogType() const {
+	return CatalogType::VIEW_ENTRY;
+}
+
+void AlterViewInfo::Serialize(FieldWriter &writer) const {
+	writer.WriteField<AlterViewType>(alter_view_type);
+	writer.WriteString(schema);
+	writer.WriteString(name);
+	SerializeAlterView(writer);
+}
+
+unique_ptr<AlterInfo> AlterViewInfo::Deserialize(FieldReader &reader) {
+	auto type = reader.ReadRequired<AlterViewType>();
+	auto schema = reader.ReadRequired<string>();
+	auto view = reader.ReadRequired<string>();
 	unique_ptr<AlterViewInfo> info;
 	switch (type) {
 	case AlterViewType::RENAME_VIEW:
-		return RenameViewInfo::Deserialize(source, schema, view);
+		return RenameViewInfo::Deserialize(reader, schema, view);
 	default:
 		throw SerializationException("Unknown alter view type for deserialization!");
 	}
@@ -129469,17 +129911,22 @@ unique_ptr<AlterInfo> AlterViewInfo::Deserialize(Deserializer &source) {
 //===--------------------------------------------------------------------===//
 // RenameViewInfo
 //===--------------------------------------------------------------------===//
+RenameViewInfo::RenameViewInfo(string schema_p, string view_p, string new_name_p)
+    : AlterViewInfo(AlterViewType::RENAME_VIEW, move(schema_p), move(view_p)), new_view_name(move(new_name_p)) {
+}
+RenameViewInfo::~RenameViewInfo() {
+}
+
 unique_ptr<AlterInfo> RenameViewInfo::Copy() const {
 	return make_unique_base<AlterInfo, RenameViewInfo>(schema, name, new_view_name);
 }
 
-void RenameViewInfo::Serialize(Serializer &serializer) {
-	AlterViewInfo::Serialize(serializer);
-	serializer.WriteString(new_view_name);
+void RenameViewInfo::SerializeAlterView(FieldWriter &writer) const {
+	writer.WriteString(new_view_name);
 }
 
-unique_ptr<AlterInfo> RenameViewInfo::Deserialize(Deserializer &source, string schema, string view) {
-	auto new_name = source.Read<string>();
+unique_ptr<AlterInfo> RenameViewInfo::Deserialize(FieldReader &reader, string schema, string view) {
+	auto new_name = reader.ReadRequired<string>();
 	return make_unique<RenameViewInfo>(move(schema), move(view), new_name);
 }
 } // namespace duckdb
@@ -129502,18 +129949,24 @@ string SampleMethodToString(SampleMethod method) {
 }
 
 void SampleOptions::Serialize(Serializer &serializer) {
-	sample_size.Serialize(serializer);
-	serializer.Write<bool>(is_percentage);
-	serializer.Write<SampleMethod>(method);
-	serializer.Write<int64_t>(seed);
+	FieldWriter writer(serializer);
+	writer.WriteSerializable(sample_size);
+	writer.WriteField<bool>(is_percentage);
+	writer.WriteField<SampleMethod>(method);
+	writer.WriteField<int64_t>(seed);
+	writer.Finalize();
 }
 
 unique_ptr<SampleOptions> SampleOptions::Deserialize(Deserializer &source) {
 	auto result = make_unique<SampleOptions>();
-	result->sample_size = Value::Deserialize(source);
-	result->is_percentage = source.Read<bool>();
-	result->method = source.Read<SampleMethod>();
-	result->seed = source.Read<int64_t>();
+
+	FieldReader reader(source);
+	result->sample_size = reader.ReadRequiredSerializable<Value, Value>();
+	result->is_percentage = reader.ReadRequired<bool>();
+	result->method = reader.ReadRequired<SampleMethod>();
+	result->seed = reader.ReadRequired<int64_t>();
+	reader.Finalize();
+
 	return result;
 }
 
@@ -129640,73 +130093,78 @@ hash_t ParsedExpression::Hash() const {
 	return hash;
 }
 
-void ParsedExpression::Serialize(Serializer &serializer) {
-	serializer.Write<ExpressionClass>(GetExpressionClass());
-	serializer.Write<ExpressionType>(type);
-	serializer.WriteString(alias);
+void ParsedExpression::Serialize(Serializer &serializer) const {
+	FieldWriter writer(serializer);
+	writer.WriteField<ExpressionClass>(GetExpressionClass());
+	writer.WriteField<ExpressionType>(type);
+	writer.WriteString(alias);
+	Serialize(writer);
+	writer.Finalize();
 }
 
 unique_ptr<ParsedExpression> ParsedExpression::Deserialize(Deserializer &source) {
-	auto expression_class = source.Read<ExpressionClass>();
-	auto type = source.Read<ExpressionType>();
-	auto alias = source.Read<string>();
+	FieldReader reader(source);
+	auto expression_class = reader.ReadRequired<ExpressionClass>();
+	auto type = reader.ReadRequired<ExpressionType>();
+	auto alias = reader.ReadRequired<string>();
 	unique_ptr<ParsedExpression> result;
 	switch (expression_class) {
 	case ExpressionClass::BETWEEN:
-		result = BetweenExpression::Deserialize(type, source);
+		result = BetweenExpression::Deserialize(type, reader);
 		break;
 	case ExpressionClass::CASE:
-		result = CaseExpression::Deserialize(type, source);
+		result = CaseExpression::Deserialize(type, reader);
 		break;
 	case ExpressionClass::CAST:
-		result = CastExpression::Deserialize(type, source);
+		result = CastExpression::Deserialize(type, reader);
 		break;
 	case ExpressionClass::COLLATE:
-		result = CollateExpression::Deserialize(type, source);
+		result = CollateExpression::Deserialize(type, reader);
 		break;
 	case ExpressionClass::COLUMN_REF:
-		result = ColumnRefExpression::Deserialize(type, source);
+		result = ColumnRefExpression::Deserialize(type, reader);
 		break;
 	case ExpressionClass::COMPARISON:
-		result = ComparisonExpression::Deserialize(type, source);
+		result = ComparisonExpression::Deserialize(type, reader);
 		break;
 	case ExpressionClass::CONJUNCTION:
-		result = ConjunctionExpression::Deserialize(type, source);
+		result = ConjunctionExpression::Deserialize(type, reader);
 		break;
 	case ExpressionClass::CONSTANT:
-		result = ConstantExpression::Deserialize(type, source);
+		result = ConstantExpression::Deserialize(type, reader);
 		break;
 	case ExpressionClass::DEFAULT:
-		result = DefaultExpression::Deserialize(type, source);
+		result = DefaultExpression::Deserialize(type, reader);
 		break;
 	case ExpressionClass::FUNCTION:
-		result = FunctionExpression::Deserialize(type, source);
+		result = FunctionExpression::Deserialize(type, reader);
 		break;
 	case ExpressionClass::LAMBDA:
-		result = LambdaExpression::Deserialize(type, source);
+		result = LambdaExpression::Deserialize(type, reader);
 		break;
 	case ExpressionClass::OPERATOR:
-		result = OperatorExpression::Deserialize(type, source);
+		result = OperatorExpression::Deserialize(type, reader);
 		break;
 	case ExpressionClass::PARAMETER:
-		result = ParameterExpression::Deserialize(type, source);
+		result = ParameterExpression::Deserialize(type, reader);
 		break;
 	case ExpressionClass::POSITIONAL_REFERENCE:
-		result = PositionalReferenceExpression::Deserialize(type, source);
+		result = PositionalReferenceExpression::Deserialize(type, reader);
 		break;
 	case ExpressionClass::STAR:
-		result = StarExpression::Deserialize(type, source);
+		result = StarExpression::Deserialize(type, reader);
 		break;
 	case ExpressionClass::SUBQUERY:
-		result = SubqueryExpression::Deserialize(type, source);
+		result = SubqueryExpression::Deserialize(type, reader);
 		break;
 	case ExpressionClass::WINDOW:
-		result = WindowExpression::Deserialize(type, source);
+		result = WindowExpression::Deserialize(type, reader);
 		break;
 	default:
 		throw SerializationException("Unsupported type for expression deserialization!");
 	}
 	result->alias = alias;
+	reader.Finalize();
 	return result;
 }
 
@@ -129752,12 +130210,12 @@ public:
 public:
 	bool Equals(const QueryNode *other) const override;
 	//! Create a copy of this SelectNode
-	unique_ptr<QueryNode> Copy() override;
+	unique_ptr<QueryNode> Copy() const override;
 
-	//! Serializes a SelectNode to a stand-alone binary blob
-	void Serialize(Serializer &serializer) override;
-	//! Deserializes a blob back into a SelectNode
-	static unique_ptr<QueryNode> Deserialize(Deserializer &source);
+	//! Serializes a QueryNode to a stand-alone binary blob
+	void Serialize(FieldWriter &writer) const override;
+	//! Deserializes a blob back into a QueryNode
+	static unique_ptr<QueryNode> Deserialize(FieldReader &reader);
 };
 
 } // namespace duckdb
@@ -135715,6 +136173,7 @@ string QueryErrorContext::FormatErrorRecursive(const string &msg, vector<Excepti
 } // namespace duckdb
 
 
+
 namespace duckdb {
 
 bool RecursiveCTENode::Equals(const QueryNode *other_p) const {
@@ -135738,7 +136197,7 @@ bool RecursiveCTENode::Equals(const QueryNode *other_p) const {
 	return true;
 }
 
-unique_ptr<QueryNode> RecursiveCTENode::Copy() {
+unique_ptr<QueryNode> RecursiveCTENode::Copy() const {
 	auto result = make_unique<RecursiveCTENode>();
 	result->ctename = ctename;
 	result->union_all = union_all;
@@ -135749,22 +136208,21 @@ unique_ptr<QueryNode> RecursiveCTENode::Copy() {
 	return move(result);
 }
 
-void RecursiveCTENode::Serialize(Serializer &serializer) {
-	QueryNode::Serialize(serializer);
-	serializer.WriteString(ctename);
-	serializer.WriteString(union_all ? "T" : "F");
-	left->Serialize(serializer);
-	right->Serialize(serializer);
-	serializer.WriteStringVector(aliases);
+void RecursiveCTENode::Serialize(FieldWriter &writer) const {
+	writer.WriteString(ctename);
+	writer.WriteField<bool>(union_all);
+	writer.WriteSerializable(*left);
+	writer.WriteSerializable(*right);
+	writer.WriteList<string>(aliases);
 }
 
-unique_ptr<QueryNode> RecursiveCTENode::Deserialize(Deserializer &source) {
+unique_ptr<QueryNode> RecursiveCTENode::Deserialize(FieldReader &reader) {
 	auto result = make_unique<RecursiveCTENode>();
-	result->ctename = source.Read<string>();
-	result->union_all = source.Read<string>() == "T" ? true : false;
-	result->left = QueryNode::Deserialize(source);
-	result->right = QueryNode::Deserialize(source);
-	source.ReadStringVector(result->aliases);
+	result->ctename = reader.ReadRequired<string>();
+	result->union_all = reader.ReadRequired<bool>();
+	result->left = reader.ReadRequiredSerializable<QueryNode>();
+	result->right = reader.ReadRequiredSerializable<QueryNode>();
+	result->aliases = reader.ReadRequiredList<string>();
 	return move(result);
 }
 
@@ -135772,6 +136230,7 @@ unique_ptr<QueryNode> RecursiveCTENode::Deserialize(Deserializer &source) {
 
 
 
+
 namespace duckdb {
 
 SelectNode::SelectNode()
@@ -135827,7 +136286,7 @@ bool SelectNode::Equals(const QueryNode *other_p) const {
 	return true;
 }
 
-unique_ptr<QueryNode> SelectNode::Copy() {
+unique_ptr<QueryNode> SelectNode::Copy() const {
 	auto result = make_unique<SelectNode>();
 	for (auto &child : select_list) {
 		result->select_list.push_back(child->Copy());
@@ -135847,42 +136306,34 @@ unique_ptr<QueryNode> SelectNode::Copy() {
 	return move(result);
 }
 
-void SelectNode::Serialize(Serializer &serializer) {
-	QueryNode::Serialize(serializer);
-	// select_list
-	serializer.WriteList(select_list);
-	// from clause
-	serializer.WriteOptional(from_table);
-	// where_clause
-	serializer.WriteOptional(where_clause);
-	// group by
-	serializer.WriteList(groups.group_expressions);
-	serializer.Write<idx_t>(groups.grouping_sets.size());
+void SelectNode::Serialize(FieldWriter &writer) const {
+	writer.WriteSerializableList(select_list);
+	writer.WriteOptional(from_table);
+	writer.WriteOptional(where_clause);
+	writer.WriteSerializableList(groups.group_expressions);
+	writer.WriteField<uint32_t>(groups.grouping_sets.size());
+	auto &serializer = writer.GetSerializer();
 	for (auto &grouping_set : groups.grouping_sets) {
 		serializer.Write<idx_t>(grouping_set.size());
 		for (auto &idx : grouping_set) {
 			serializer.Write<idx_t>(idx);
 		}
 	}
-	serializer.Write<AggregateHandling>(aggregate_handling);
-	// having / sample
-	serializer.WriteOptional(having);
-	serializer.WriteOptional(sample);
-	// qualify
-	serializer.WriteOptional(qualify);
+	writer.WriteField<AggregateHandling>(aggregate_handling);
+	writer.WriteOptional(having);
+	writer.WriteOptional(sample);
+	writer.WriteOptional(qualify);
 }
 
-unique_ptr<QueryNode> SelectNode::Deserialize(Deserializer &source) {
+unique_ptr<QueryNode> SelectNode::Deserialize(FieldReader &reader) {
 	auto result = make_unique<SelectNode>();
-	// select_list
-	source.ReadList<ParsedExpression>(result->select_list);
-	// from clause
-	result->from_table = source.ReadOptional<TableRef>();
-	// where_clause
-	result->where_clause = source.ReadOptional<ParsedExpression>();
-	// group by
-	source.ReadList<ParsedExpression>(result->groups.group_expressions);
-	auto grouping_set_count = source.Read<idx_t>();
+	result->select_list = reader.ReadRequiredSerializableList<ParsedExpression>();
+	result->from_table = reader.ReadOptional<TableRef>(nullptr);
+	result->where_clause = reader.ReadOptional<ParsedExpression>(nullptr);
+	result->groups.group_expressions = reader.ReadRequiredSerializableList<ParsedExpression>();
+
+	auto grouping_set_count = reader.ReadRequired<uint32_t>();
+	auto &source = reader.GetSource();
 	for (idx_t set_idx = 0; set_idx < grouping_set_count; set_idx++) {
 		auto set_entries = source.Read<idx_t>();
 		GroupingSet grouping_set;
@@ -135891,19 +136342,17 @@ unique_ptr<QueryNode> SelectNode::Deserialize(Deserializer &source) {
 		}
 		result->groups.grouping_sets.push_back(grouping_set);
 	}
-	result->aggregate_handling = source.Read<AggregateHandling>();
-
-	// having / sample
-	result->having = source.ReadOptional<ParsedExpression>();
-	result->sample = source.ReadOptional<SampleOptions>();
-	// qualify
-	result->qualify = source.ReadOptional<ParsedExpression>();
+	result->aggregate_handling = reader.ReadRequired<AggregateHandling>();
+	result->having = reader.ReadOptional<ParsedExpression>(nullptr);
+	result->sample = reader.ReadOptional<SampleOptions>(nullptr);
+	result->qualify = reader.ReadOptional<ParsedExpression>(nullptr);
 	return move(result);
 }
 
 } // namespace duckdb
 
 
+
 namespace duckdb {
 
 bool SetOperationNode::Equals(const QueryNode *other_p) const {
@@ -135926,7 +136375,7 @@ bool SetOperationNode::Equals(const QueryNode *other_p) const {
 	return true;
 }
 
-unique_ptr<QueryNode> SetOperationNode::Copy() {
+unique_ptr<QueryNode> SetOperationNode::Copy() const {
 	auto result = make_unique<SetOperationNode>();
 	result->setop_type = setop_type;
 	result->left = left->Copy();
@@ -135935,18 +136384,17 @@ unique_ptr<QueryNode> SetOperationNode::Copy() {
 	return move(result);
 }
 
-void SetOperationNode::Serialize(Serializer &serializer) {
-	QueryNode::Serialize(serializer);
-	serializer.Write<SetOperationType>(setop_type);
-	left->Serialize(serializer);
-	right->Serialize(serializer);
+void SetOperationNode::Serialize(FieldWriter &writer) const {
+	writer.WriteField<SetOperationType>(setop_type);
+	writer.WriteSerializable(*left);
+	writer.WriteSerializable(*right);
 }
 
-unique_ptr<QueryNode> SetOperationNode::Deserialize(Deserializer &source) {
+unique_ptr<QueryNode> SetOperationNode::Deserialize(FieldReader &reader) {
 	auto result = make_unique<SetOperationNode>();
-	result->setop_type = source.Read<SetOperationType>();
-	result->left = QueryNode::Deserialize(source);
-	result->right = QueryNode::Deserialize(source);
+	result->setop_type = reader.ReadRequired<SetOperationType>();
+	result->left = reader.ReadRequiredSerializable<QueryNode>();
+	result->right = reader.ReadRequiredSerializable<QueryNode>();
 	return move(result);
 }
 
@@ -135958,6 +136406,7 @@ unique_ptr<QueryNode> SetOperationNode::Deserialize(Deserializer &source) {
 
 
 
+
 namespace duckdb {
 
 bool QueryNode::Equals(const QueryNode *other) const {
@@ -136011,32 +136460,30 @@ void QueryNode::CopyProperties(QueryNode &other) const {
 	}
 }
 
-void QueryNode::Serialize(Serializer &serializer) {
-	serializer.Write<QueryNodeType>(type);
-	serializer.Write<idx_t>(modifiers.size());
-	for (idx_t i = 0; i < modifiers.size(); i++) {
-		modifiers[i]->Serialize(serializer);
-	}
+void QueryNode::Serialize(Serializer &main_serializer) const {
+	FieldWriter writer(main_serializer);
+	writer.WriteField<QueryNodeType>(type);
+	writer.WriteSerializableList(modifiers);
 	// cte_map
-	D_ASSERT(cte_map.size() <= NumericLimits<uint32_t>::Maximum());
-	serializer.Write<uint32_t>((uint32_t)cte_map.size());
+	writer.WriteField<uint32_t>((uint32_t)cte_map.size());
+	auto &serializer = writer.GetSerializer();
 	for (auto &cte : cte_map) {
 		serializer.WriteString(cte.first);
 		serializer.WriteStringVector(cte.second->aliases);
 		cte.second->query->Serialize(serializer);
 	}
+	Serialize(writer);
+	writer.Finalize();
 }
 
-unique_ptr<QueryNode> QueryNode::Deserialize(Deserializer &source) {
-	unique_ptr<QueryNode> result;
-	auto type = source.Read<QueryNodeType>();
-	auto modifier_count = source.Read<idx_t>();
-	vector<unique_ptr<ResultModifier>> modifiers;
-	for (idx_t i = 0; i < modifier_count; i++) {
-		modifiers.push_back(ResultModifier::Deserialize(source));
-	}
+unique_ptr<QueryNode> QueryNode::Deserialize(Deserializer &main_source) {
+	FieldReader reader(main_source);
+
+	auto type = reader.ReadRequired<QueryNodeType>();
+	auto modifiers = reader.ReadRequiredSerializableList<ResultModifier>();
 	// cte_map
-	auto cte_count = source.Read<uint32_t>();
+	auto cte_count = reader.ReadRequired<uint32_t>();
+	auto &source = reader.GetSource();
 	unordered_map<string, unique_ptr<CommonTableExpressionInfo>> cte_map;
 	for (idx_t i = 0; i < cte_count; i++) {
 		auto name = source.Read<string>();
@@ -136045,15 +136492,17 @@ unique_ptr<QueryNode> QueryNode::Deserialize(Deserializer &source) {
 		info->query = SelectStatement::Deserialize(source);
 		cte_map[name] = move(info);
 	}
+
+	unique_ptr<QueryNode> result;
 	switch (type) {
 	case QueryNodeType::SELECT_NODE:
-		result = SelectNode::Deserialize(source);
+		result = SelectNode::Deserialize(reader);
 		break;
 	case QueryNodeType::SET_OPERATION_NODE:
-		result = SetOperationNode::Deserialize(source);
+		result = SetOperationNode::Deserialize(reader);
 		break;
 	case QueryNodeType::RECURSIVE_CTE_NODE:
-		result = RecursiveCTENode::Deserialize(source);
+		result = RecursiveCTENode::Deserialize(reader);
 		break;
 	default:
 		throw SerializationException("Could not deserialize Query Node: unknown type!");
@@ -136077,24 +136526,35 @@ bool ResultModifier::Equals(const ResultModifier *other) const {
 	return type == other->type;
 }
 
-void ResultModifier::Serialize(Serializer &serializer) {
-	serializer.Write<ResultModifierType>(type);
+void ResultModifier::Serialize(Serializer &serializer) const {
+	FieldWriter writer(serializer);
+	writer.WriteField<ResultModifierType>(type);
+	Serialize(writer);
+	writer.Finalize();
 }
 
 unique_ptr<ResultModifier> ResultModifier::Deserialize(Deserializer &source) {
-	auto type = source.Read<ResultModifierType>();
+	FieldReader reader(source);
+	auto type = reader.ReadRequired<ResultModifierType>();
+
+	unique_ptr<ResultModifier> result;
 	switch (type) {
 	case ResultModifierType::LIMIT_MODIFIER:
-		return LimitModifier::Deserialize(source);
+		result = LimitModifier::Deserialize(reader);
+		break;
 	case ResultModifierType::ORDER_MODIFIER:
-		return OrderModifier::Deserialize(source);
+		result = OrderModifier::Deserialize(reader);
+		break;
 	case ResultModifierType::DISTINCT_MODIFIER:
-		return DistinctModifier::Deserialize(source);
+		result = DistinctModifier::Deserialize(reader);
+		break;
 	case ResultModifierType::LIMIT_PERCENT_MODIFIER:
-		return LimitPercentModifier::Deserialize(source);
+		result = LimitPercentModifier::Deserialize(reader);
+		break;
 	default:
 		throw InternalException("Unrecognized ResultModifierType for Deserialization");
 	}
+	return result;
 }
 
 bool LimitModifier::Equals(const ResultModifier *other_p) const {
@@ -136111,7 +136571,7 @@ bool LimitModifier::Equals(const ResultModifier *other_p) const {
 	return true;
 }
 
-unique_ptr<ResultModifier> LimitModifier::Copy() {
+unique_ptr<ResultModifier> LimitModifier::Copy() const {
 	auto copy = make_unique<LimitModifier>();
 	if (limit) {
 		copy->limit = limit->Copy();
@@ -136122,16 +136582,15 @@ unique_ptr<ResultModifier> LimitModifier::Copy() {
 	return move(copy);
 }
 
-void LimitModifier::Serialize(Serializer &serializer) {
-	ResultModifier::Serialize(serializer);
-	serializer.WriteOptional(limit);
-	serializer.WriteOptional(offset);
+void LimitModifier::Serialize(FieldWriter &writer) const {
+	writer.WriteOptional(limit);
+	writer.WriteOptional(offset);
 }
 
-unique_ptr<ResultModifier> LimitModifier::Deserialize(Deserializer &source) {
+unique_ptr<ResultModifier> LimitModifier::Deserialize(FieldReader &reader) {
 	auto mod = make_unique<LimitModifier>();
-	mod->limit = source.ReadOptional<ParsedExpression>();
-	mod->offset = source.ReadOptional<ParsedExpression>();
+	mod->limit = reader.ReadOptional<ParsedExpression>(nullptr);
+	mod->offset = reader.ReadOptional<ParsedExpression>(nullptr);
 	return move(mod);
 }
 
@@ -136146,7 +136605,7 @@ bool DistinctModifier::Equals(const ResultModifier *other_p) const {
 	return true;
 }
 
-unique_ptr<ResultModifier> DistinctModifier::Copy() {
+unique_ptr<ResultModifier> DistinctModifier::Copy() const {
 	auto copy = make_unique<DistinctModifier>();
 	for (auto &expr : distinct_on_targets) {
 		copy->distinct_on_targets.push_back(expr->Copy());
@@ -136154,14 +136613,13 @@ unique_ptr<ResultModifier> DistinctModifier::Copy() {
 	return move(copy);
 }
 
-void DistinctModifier::Serialize(Serializer &serializer) {
-	ResultModifier::Serialize(serializer);
-	serializer.WriteList(distinct_on_targets);
+void DistinctModifier::Serialize(FieldWriter &writer) const {
+	writer.WriteSerializableList(distinct_on_targets);
 }
 
-unique_ptr<ResultModifier> DistinctModifier::Deserialize(Deserializer &source) {
+unique_ptr<ResultModifier> DistinctModifier::Deserialize(FieldReader &reader) {
 	auto mod = make_unique<DistinctModifier>();
-	source.ReadList<ParsedExpression>(mod->distinct_on_targets);
+	mod->distinct_on_targets = reader.ReadRequiredSerializableList<ParsedExpression>();
 	return move(mod);
 }
 
@@ -136184,7 +136642,7 @@ bool OrderModifier::Equals(const ResultModifier *other_p) const {
 	return true;
 }
 
-unique_ptr<ResultModifier> OrderModifier::Copy() {
+unique_ptr<ResultModifier> OrderModifier::Copy() const {
 	auto copy = make_unique<OrderModifier>();
 	for (auto &order : orders) {
 		copy->orders.emplace_back(order.type, order.null_order, order.expression->Copy());
@@ -136218,33 +136676,29 @@ string OrderByNode::ToString() const {
 	return str;
 }
 
-void OrderByNode::Serialize(Serializer &serializer) {
-	serializer.Write<OrderType>(type);
-	serializer.Write<OrderByNullType>(null_order);
-	expression->Serialize(serializer);
+void OrderByNode::Serialize(Serializer &serializer) const {
+	FieldWriter writer(serializer);
+	writer.WriteField<OrderType>(type);
+	writer.WriteField<OrderByNullType>(null_order);
+	writer.WriteSerializable(*expression);
+	writer.Finalize();
 }
 
 OrderByNode OrderByNode::Deserialize(Deserializer &source) {
-	auto type = source.Read<OrderType>();
-	auto null_order = source.Read<OrderByNullType>();
-	auto expression = ParsedExpression::Deserialize(source);
+	FieldReader reader(source);
+	auto type = reader.ReadRequired<OrderType>();
+	auto null_order = reader.ReadRequired<OrderByNullType>();
+	auto expression = reader.ReadRequiredSerializable<ParsedExpression>();
 	return OrderByNode(type, null_order, move(expression));
 }
 
-void OrderModifier::Serialize(Serializer &serializer) {
-	ResultModifier::Serialize(serializer);
-	serializer.Write<int64_t>(orders.size());
-	for (auto &order : orders) {
-		order.Serialize(serializer);
-	}
+void OrderModifier::Serialize(FieldWriter &writer) const {
+	writer.WriteRegularSerializableList(orders);
 }
 
-unique_ptr<ResultModifier> OrderModifier::Deserialize(Deserializer &source) {
+unique_ptr<ResultModifier> OrderModifier::Deserialize(FieldReader &reader) {
 	auto mod = make_unique<OrderModifier>();
-	auto order_count = source.Read<int64_t>();
-	for (int64_t i = 0; i < order_count; i++) {
-		mod->orders.push_back(OrderByNode::Deserialize((source)));
-	}
+	mod->orders = reader.ReadRequiredSerializableList<OrderByNode, OrderByNode>();
 	return move(mod);
 }
 
@@ -136262,7 +136716,7 @@ bool LimitPercentModifier::Equals(const ResultModifier *other_p) const {
 	return true;
 }
 
-unique_ptr<ResultModifier> LimitPercentModifier::Copy() {
+unique_ptr<ResultModifier> LimitPercentModifier::Copy() const {
 	auto copy = make_unique<LimitPercentModifier>();
 	if (limit) {
 		copy->limit = limit->Copy();
@@ -136273,16 +136727,15 @@ unique_ptr<ResultModifier> LimitPercentModifier::Copy() {
 	return move(copy);
 }
 
-void LimitPercentModifier::Serialize(Serializer &serializer) {
-	ResultModifier::Serialize(serializer);
-	serializer.WriteOptional(limit);
-	serializer.WriteOptional(offset);
+void LimitPercentModifier::Serialize(FieldWriter &writer) const {
+	writer.WriteOptional(limit);
+	writer.WriteOptional(offset);
 }
 
-unique_ptr<ResultModifier> LimitPercentModifier::Deserialize(Deserializer &source) {
+unique_ptr<ResultModifier> LimitPercentModifier::Deserialize(FieldReader &reader) {
 	auto mod = make_unique<LimitPercentModifier>();
-	mod->limit = source.ReadOptional<ParsedExpression>();
-	mod->offset = source.ReadOptional<ParsedExpression>();
+	mod->limit = reader.ReadOptional<ParsedExpression>(nullptr);
+	mod->offset = reader.ReadOptional<ParsedExpression>(nullptr);
 	return move(mod);
 }
 
@@ -136618,7 +137071,7 @@ unique_ptr<SQLStatement> SelectStatement::Copy() const {
 	return move(result);
 }
 
-void SelectStatement::Serialize(Serializer &serializer) {
+void SelectStatement::Serialize(Serializer &serializer) const {
 	node->Serialize(serializer);
 }
 
@@ -136838,20 +137291,18 @@ bool BaseTableRef::Equals(const TableRef *other_p) const {
 	       column_name_alias == other->column_name_alias;
 }
 
-void BaseTableRef::Serialize(Serializer &serializer) {
-	TableRef::Serialize(serializer);
-
-	serializer.WriteString(schema_name);
-	serializer.WriteString(table_name);
-	serializer.WriteStringVector(column_name_alias);
+void BaseTableRef::Serialize(FieldWriter &writer) const {
+	writer.WriteString(schema_name);
+	writer.WriteString(table_name);
+	writer.WriteList<string>(column_name_alias);
 }
 
-unique_ptr<TableRef> BaseTableRef::Deserialize(Deserializer &source) {
+unique_ptr<TableRef> BaseTableRef::Deserialize(FieldReader &reader) {
 	auto result = make_unique<BaseTableRef>();
 
-	result->schema_name = source.Read<string>();
-	result->table_name = source.Read<string>();
-	source.ReadStringVector(result->column_name_alias);
+	result->schema_name = reader.ReadRequired<string>();
+	result->table_name = reader.ReadRequired<string>();
+	result->column_name_alias = reader.ReadRequiredList<string>();
 
 	return move(result);
 }
@@ -136889,22 +137340,18 @@ unique_ptr<TableRef> CrossProductRef::Copy() {
 	return move(copy);
 }
 
-void CrossProductRef::Serialize(Serializer &serializer) {
-	TableRef::Serialize(serializer);
-
-	left->Serialize(serializer);
-	right->Serialize(serializer);
+void CrossProductRef::Serialize(FieldWriter &writer) const {
+	writer.WriteSerializable(*left);
+	writer.WriteSerializable(*right);
 }
 
-unique_ptr<TableRef> CrossProductRef::Deserialize(Deserializer &source) {
+unique_ptr<TableRef> CrossProductRef::Deserialize(FieldReader &reader) {
 	auto result = make_unique<CrossProductRef>();
 
-	result->left = TableRef::Deserialize(source);
-	result->right = TableRef::Deserialize(source);
-
-	if (!result->left || !result->right) {
-		return nullptr;
-	}
+	result->left = reader.ReadRequiredSerializable<TableRef>();
+	result->right = reader.ReadRequiredSerializable<TableRef>();
+	D_ASSERT(result->left);
+	D_ASSERT(result->right);
 
 	return move(result);
 }
@@ -136924,11 +137371,10 @@ unique_ptr<TableRef> EmptyTableRef::Copy() {
 	return make_unique<EmptyTableRef>();
 }
 
-void EmptyTableRef::Serialize(Serializer &serializer) {
-	TableRef::Serialize(serializer);
+void EmptyTableRef::Serialize(FieldWriter &writer) const {
 }
 
-unique_ptr<TableRef> EmptyTableRef::Deserialize(Deserializer &source) {
+unique_ptr<TableRef> EmptyTableRef::Deserialize(FieldReader &reader) {
 	return make_unique<EmptyTableRef>();
 }
 
@@ -136977,34 +137423,23 @@ unique_ptr<TableRef> ExpressionListRef::Copy() {
 	return move(result);
 }
 
-void ExpressionListRef::Serialize(Serializer &serializer) {
-	TableRef::Serialize(serializer);
-	serializer.Write<idx_t>(expected_names.size());
-	for (idx_t i = 0; i < expected_names.size(); i++) {
-		serializer.WriteString(expected_names[i]);
-	}
-	serializer.Write<idx_t>(expected_types.size());
-	for (idx_t i = 0; i < expected_types.size(); i++) {
-		expected_types[i].Serialize(serializer);
-	}
-	serializer.Write<idx_t>(values.size());
+void ExpressionListRef::Serialize(FieldWriter &writer) const {
+	writer.WriteList<string>(expected_names);
+	writer.WriteRegularSerializableList<LogicalType>(expected_types);
+	auto &serializer = writer.GetSerializer();
+	writer.WriteField<uint32_t>(values.size());
 	for (idx_t i = 0; i < values.size(); i++) {
 		serializer.WriteList(values[i]);
 	}
 }
 
-unique_ptr<TableRef> ExpressionListRef::Deserialize(Deserializer &source) {
+unique_ptr<TableRef> ExpressionListRef::Deserialize(FieldReader &reader) {
 	auto result = make_unique<ExpressionListRef>();
 	// value list
-	auto name_count = source.Read<idx_t>();
-	for (idx_t i = 0; i < name_count; i++) {
-		result->expected_names.push_back(source.Read<string>());
-	}
-	auto type_count = source.Read<idx_t>();
-	for (idx_t i = 0; i < type_count; i++) {
-		result->expected_types.push_back(LogicalType::Deserialize(source));
-	}
-	idx_t value_list_size = source.Read<idx_t>();
+	result->expected_names = reader.ReadRequiredList<string>();
+	result->expected_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
+	idx_t value_list_size = reader.ReadRequired<uint32_t>();
+	auto &source = reader.GetSource();
 	for (idx_t i = 0; i < value_list_size; i++) {
 		vector<unique_ptr<ParsedExpression>> value_list;
 		source.ReadList<ParsedExpression>(value_list);
@@ -137052,33 +137487,23 @@ unique_ptr<TableRef> JoinRef::Copy() {
 	return move(copy);
 }
 
-void JoinRef::Serialize(Serializer &serializer) {
-	TableRef::Serialize(serializer);
-
-	left->Serialize(serializer);
-	right->Serialize(serializer);
-	serializer.WriteOptional(condition);
-	serializer.Write<JoinType>(type);
-	serializer.Write<bool>(is_natural);
-	D_ASSERT(using_columns.size() <= NumericLimits<uint32_t>::Maximum());
-	serializer.Write<uint32_t>((uint32_t)using_columns.size());
-	for (auto &using_column : using_columns) {
-		serializer.WriteString(using_column);
-	}
+void JoinRef::Serialize(FieldWriter &writer) const {
+	writer.WriteSerializable(*left);
+	writer.WriteSerializable(*right);
+	writer.WriteOptional(condition);
+	writer.WriteField<JoinType>(type);
+	writer.WriteField<bool>(is_natural);
+	writer.WriteList<string>(using_columns);
 }
 
-unique_ptr<TableRef> JoinRef::Deserialize(Deserializer &source) {
+unique_ptr<TableRef> JoinRef::Deserialize(FieldReader &reader) {
 	auto result = make_unique<JoinRef>();
-
-	result->left = TableRef::Deserialize(source);
-	result->right = TableRef::Deserialize(source);
-	result->condition = source.ReadOptional<ParsedExpression>();
-	result->type = source.Read<JoinType>();
-	result->is_natural = source.Read<bool>();
-	auto count = source.Read<uint32_t>();
-	for (idx_t i = 0; i < count; i++) {
-		result->using_columns.push_back(source.Read<string>());
-	}
+	result->left = reader.ReadRequiredSerializable<TableRef>();
+	result->right = reader.ReadRequiredSerializable<TableRef>();
+	result->condition = reader.ReadOptional<ParsedExpression>(nullptr);
+	result->type = reader.ReadRequired<JoinType>();
+	result->is_natural = reader.ReadRequired<bool>();
+	result->using_columns = reader.ReadRequiredList<string>();
 	return move(result);
 }
 
@@ -137110,19 +137535,15 @@ unique_ptr<TableRef> SubqueryRef::Copy() {
 	return move(copy);
 }
 
-void SubqueryRef::Serialize(Serializer &serializer) {
-	TableRef::Serialize(serializer);
-	subquery->Serialize(serializer);
-	serializer.WriteStringVector(column_name_alias);
+void SubqueryRef::Serialize(FieldWriter &writer) const {
+	writer.WriteSerializable(*subquery);
+	writer.WriteList<string>(column_name_alias);
 }
 
-unique_ptr<TableRef> SubqueryRef::Deserialize(Deserializer &source) {
-	auto subquery = SelectStatement::Deserialize(source);
-	if (!subquery) {
-		return nullptr;
-	}
+unique_ptr<TableRef> SubqueryRef::Deserialize(FieldReader &reader) {
+	auto subquery = reader.ReadRequiredSerializable<SelectStatement>();
 	auto result = make_unique<SubqueryRef>(move(subquery));
-	source.ReadStringVector(result->column_name_alias);
+	result->column_name_alias = reader.ReadRequiredList<string>();
 	return move(result);
 }
 
@@ -137145,20 +137566,17 @@ bool TableFunctionRef::Equals(const TableRef *other_p) const {
 	return function->Equals(other->function.get());
 }
 
-void TableFunctionRef::Serialize(Serializer &serializer) {
-	TableRef::Serialize(serializer);
-	function->Serialize(serializer);
-	serializer.WriteString(alias);
-	serializer.WriteStringVector(column_name_alias);
+void TableFunctionRef::Serialize(FieldWriter &writer) const {
+	writer.WriteSerializable(*function);
+	writer.WriteString(alias);
+	writer.WriteList<string>(column_name_alias);
 }
 
-unique_ptr<TableRef> TableFunctionRef::Deserialize(Deserializer &source) {
+unique_ptr<TableRef> TableFunctionRef::Deserialize(FieldReader &reader) {
 	auto result = make_unique<TableFunctionRef>();
-
-	result->function = ParsedExpression::Deserialize(source);
-	result->alias = source.Read<string>();
-	source.ReadStringVector(result->column_name_alias);
-
+	result->function = reader.ReadRequiredSerializable<ParsedExpression>();
+	result->alias = reader.ReadRequired<string>();
+	result->column_name_alias = reader.ReadRequiredList<string>();
 	return move(result);
 }
 
@@ -137190,44 +137608,50 @@ bool TableRef::Equals(const TableRef *other) const {
 	       SampleOptions::Equals(sample.get(), other->sample.get());
 }
 
-void TableRef::Serialize(Serializer &serializer) {
-	serializer.Write<TableReferenceType>(type);
-	serializer.WriteString(alias);
-	serializer.WriteOptional(sample);
+void TableRef::Serialize(Serializer &serializer) const {
+	FieldWriter writer(serializer);
+	writer.WriteField<TableReferenceType>(type);
+	writer.WriteString(alias);
+	writer.WriteOptional(sample);
+	Serialize(writer);
+	writer.Finalize();
 }
 
-//! Deserializes a blob back into an TableRef
 unique_ptr<TableRef> TableRef::Deserialize(Deserializer &source) {
-	auto type = source.Read<TableReferenceType>();
-	auto alias = source.Read<string>();
-	auto sample = source.ReadOptional<SampleOptions>();
+	FieldReader reader(source);
+
+	auto type = reader.ReadRequired<TableReferenceType>();
+	auto alias = reader.ReadRequired<string>();
+	auto sample = reader.ReadOptional<SampleOptions>(nullptr);
 	unique_ptr<TableRef> result;
 	switch (type) {
 	case TableReferenceType::BASE_TABLE:
-		result = BaseTableRef::Deserialize(source);
+		result = BaseTableRef::Deserialize(reader);
 		break;
 	case TableReferenceType::CROSS_PRODUCT:
-		result = CrossProductRef::Deserialize(source);
+		result = CrossProductRef::Deserialize(reader);
 		break;
 	case TableReferenceType::JOIN:
-		result = JoinRef::Deserialize(source);
+		result = JoinRef::Deserialize(reader);
 		break;
 	case TableReferenceType::SUBQUERY:
-		result = SubqueryRef::Deserialize(source);
+		result = SubqueryRef::Deserialize(reader);
 		break;
 	case TableReferenceType::TABLE_FUNCTION:
-		result = TableFunctionRef::Deserialize(source);
+		result = TableFunctionRef::Deserialize(reader);
 		break;
 	case TableReferenceType::EMPTY:
-		result = EmptyTableRef::Deserialize(source);
+		result = EmptyTableRef::Deserialize(reader);
 		break;
 	case TableReferenceType::EXPRESSION_LIST:
-		result = ExpressionListRef::Deserialize(source);
+		result = ExpressionListRef::Deserialize(reader);
 		break;
 	case TableReferenceType::CTE:
 	case TableReferenceType::INVALID:
 		throw InternalException("Unsupported type for TableRef::Deserialize");
 	}
+	reader.Finalize();
+
 	result->alias = alias;
 	result->sample = move(sample);
 	return result;
@@ -140278,7 +140702,7 @@ unique_ptr<CreateStatement> Transformer::TransformCreateEnum(duckdb_libpgquery::
 	info->name = ReadPgListToString(stmt->typeName)[0];
 	idx_t size = 0;
 	auto ordered_array = ReadPgListToVector(stmt->vals, size);
-	info->type = make_unique<LogicalType>(LogicalType::ENUM(info->name, ordered_array, size));
+	info->type = LogicalType::ENUM(info->name, ordered_array, size);
 	result->info = move(info);
 	return result;
 }
@@ -143720,11 +144144,14 @@ public:
 	unique_ptr<SelectStatement> subquery;
 
 	const vector<unique_ptr<ParsedExpression>> &GetSelectList() const override {
-		throw Exception("Cannot get select list of bound subquery node");
+		throw InternalException("Cannot get select list of bound subquery node");
 	}
 
-	unique_ptr<QueryNode> Copy() override {
-		throw Exception("Cannot copy bound subquery node");
+	unique_ptr<QueryNode> Copy() const override {
+		throw InternalException("Cannot copy bound subquery node");
+	}
+	void Serialize(FieldWriter &writer) const override {
+		throw InternalException("Cannot copy bound subquery node");
 	}
 };
 
@@ -146177,7 +146604,7 @@ void Binder::BindLogicalType(ClientContext &context, LogicalType &type, const st
 		if (!user_type_catalog) {
 			throw NotImplementedException("DataType %s not supported yet...\n", user_type_name);
 		}
-		type = *user_type_catalog->user_type;
+		type = user_type_catalog->user_type;
 		EnumType::SetCatalog(type, user_type_catalog);
 	} else if (type.id() == LogicalTypeId::ENUM) {
 		auto &enum_type_name = EnumType::GetTypeName(type);
@@ -160946,6 +161373,7 @@ private:
 
 
 
+
 #include <algorithm>
 #include <cstring>
 
@@ -160956,9 +161384,11 @@ const char MainHeader::MAGIC_BYTES[] = "DUCK";
 void MainHeader::Serialize(Serializer &ser) {
 	ser.WriteData((data_ptr_t)MAGIC_BYTES, MAGIC_BYTE_SIZE);
 	ser.Write<uint64_t>(version_number);
+	FieldWriter writer(ser);
 	for (idx_t i = 0; i < FLAG_COUNT; i++) {
-		ser.Write<uint64_t>(flags[i]);
+		writer.WriteField<uint64_t>(flags[i]);
 	}
+	writer.Finalize();
 }
 
 void MainHeader::CheckMagicBytes(FileHandle &handle) {
@@ -160981,9 +161411,11 @@ MainHeader MainHeader::Deserialize(Deserializer &source) {
 	}
 	header.version_number = source.Read<uint64_t>();
 	// read the flags
+	FieldReader reader(source);
 	for (idx_t i = 0; i < FLAG_COUNT; i++) {
-		header.flags[i] = source.Read<uint64_t>();
+		header.flags[i] = reader.ReadRequired<uint64_t>();
 	}
+	reader.Finalize();
 	return header;
 }
 
@@ -161350,7 +161782,7 @@ BaseStatistics::BaseStatistics(LogicalType type) : type(move(type)) {
 BaseStatistics::~BaseStatistics() {
 }
 
-bool BaseStatistics::CanHaveNull() {
+bool BaseStatistics::CanHaveNull() const {
 	if (!validity_stats) {
 		// we don't know
 		// solid maybe
@@ -161359,7 +161791,7 @@ bool BaseStatistics::CanHaveNull() {
 	return ((ValidityStatistics &)*validity_stats).has_null;
 }
 
-bool BaseStatistics::CanHaveNoNull() {
+bool BaseStatistics::CanHaveNoNull() const {
 	if (!validity_stats) {
 		// we don't know
 		// solid maybe
@@ -161368,14 +161800,6 @@ bool BaseStatistics::CanHaveNoNull() {
 	return ((ValidityStatistics &)*validity_stats).has_no_null;
 }
 
-unique_ptr<BaseStatistics> BaseStatistics::Copy() {
-	auto statistics = make_unique<BaseStatistics>(type);
-	if (validity_stats) {
-		statistics->validity_stats = validity_stats->Copy();
-	}
-	return statistics;
-}
-
 void BaseStatistics::Merge(const BaseStatistics &other) {
 	D_ASSERT(type == other.type);
 	if (other.validity_stats) {
@@ -161418,18 +161842,33 @@ unique_ptr<BaseStatistics> BaseStatistics::CreateEmpty(LogicalType type) {
 	}
 }
 
-void BaseStatistics::Serialize(Serializer &serializer) {
-	serializer.Write<bool>(CanHaveNull());
-	serializer.Write<bool>(CanHaveNoNull());
+unique_ptr<BaseStatistics> BaseStatistics::Copy() const {
+	auto statistics = make_unique<BaseStatistics>(type);
+	if (validity_stats) {
+		statistics->validity_stats = validity_stats->Copy();
+	}
+	return statistics;
+}
+
+void BaseStatistics::Serialize(Serializer &serializer) const {
+	FieldWriter writer(serializer);
+	writer.WriteField<bool>(CanHaveNull());
+	writer.WriteField<bool>(CanHaveNoNull());
+	Serialize(writer);
+	writer.Finalize();
+}
+
+void BaseStatistics::Serialize(FieldWriter &writer) const {
 }
 
 unique_ptr<BaseStatistics> BaseStatistics::Deserialize(Deserializer &source, LogicalType type) {
-	bool can_have_null = source.Read<bool>();
-	bool can_have_no_null = source.Read<bool>();
+	FieldReader reader(source);
+	bool can_have_null = reader.ReadRequired<bool>();
+	bool can_have_no_null = reader.ReadRequired<bool>();
 	unique_ptr<BaseStatistics> result;
 	switch (type.InternalType()) {
 	case PhysicalType::BIT:
-		return ValidityStatistics::Deserialize(source);
+		return ValidityStatistics::Deserialize(reader);
 	case PhysicalType::BOOL:
 	case PhysicalType::INT8:
 	case PhysicalType::INT16:
@@ -161442,16 +161881,16 @@ unique_ptr<BaseStatistics> BaseStatistics::Deserialize(Deserializer &source, Log
 	case PhysicalType::INT128:
 	case PhysicalType::FLOAT:
 	case PhysicalType::DOUBLE:
-		result = NumericStatistics::Deserialize(source, move(type));
+		result = NumericStatistics::Deserialize(reader, move(type));
 		break;
 	case PhysicalType::VARCHAR:
-		result = StringStatistics::Deserialize(source, move(type));
+		result = StringStatistics::Deserialize(reader, move(type));
 		break;
 	case PhysicalType::STRUCT:
-		result = StructStatistics::Deserialize(source, move(type));
+		result = StructStatistics::Deserialize(reader, move(type));
 		break;
 	case PhysicalType::LIST:
-		result = ListStatistics::Deserialize(source, move(type));
+		result = ListStatistics::Deserialize(reader, move(type));
 		break;
 	case PhysicalType::INTERVAL:
 		result = make_unique<BaseStatistics>(move(type));
@@ -161463,18 +161902,18 @@ unique_ptr<BaseStatistics> BaseStatistics::Deserialize(Deserializer &source, Log
 	return result;
 }
 
-string BaseStatistics::ToString() {
+string BaseStatistics::ToString() const {
 	return StringUtil::Format("Base Statistics %s", validity_stats ? validity_stats->ToString() : "[]");
 }
 
-void BaseStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t count) {
+void BaseStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t count) const {
 	D_ASSERT(vector.GetType() == this->type);
 	if (validity_stats) {
 		validity_stats->Verify(vector, sel, count);
 	}
 }
 
-void BaseStatistics::Verify(Vector &vector, idx_t count) {
+void BaseStatistics::Verify(Vector &vector, idx_t count) const {
 	SelectionVector owned_sel;
 	auto sel = FlatVector::IncrementalSelectionVector(count, owned_sel);
 	Verify(vector, *sel, count);
@@ -161484,6 +161923,7 @@ void BaseStatistics::Verify(Vector &vector, idx_t count) {
 
 
 
+
 namespace duckdb {
 
 ListStatistics::ListStatistics(LogicalType type_p) : BaseStatistics(move(type_p)) {
@@ -161506,32 +161946,32 @@ void ListStatistics::Merge(const BaseStatistics &other_p) {
 }
 
 // LCOV_EXCL_START
-FilterPropagateResult ListStatistics::CheckZonemap(ExpressionType comparison_type, const Value &constant) {
+FilterPropagateResult ListStatistics::CheckZonemap(ExpressionType comparison_type, const Value &constant) const {
 	throw InternalException("List zonemaps are not supported yet");
 }
 // LCOV_EXCL_STOP
 
-unique_ptr<BaseStatistics> ListStatistics::Copy() {
+unique_ptr<BaseStatistics> ListStatistics::Copy() const {
 	auto copy = make_unique<ListStatistics>(type);
 	copy->validity_stats = validity_stats ? validity_stats->Copy() : nullptr;
 	copy->child_stats = child_stats ? child_stats->Copy() : nullptr;
 	return move(copy);
 }
 
-void ListStatistics::Serialize(Serializer &serializer) {
-	BaseStatistics::Serialize(serializer);
-	child_stats->Serialize(serializer);
+void ListStatistics::Serialize(FieldWriter &writer) const {
+	writer.WriteSerializable(*child_stats);
 }
 
-unique_ptr<BaseStatistics> ListStatistics::Deserialize(Deserializer &source, LogicalType type) {
+unique_ptr<BaseStatistics> ListStatistics::Deserialize(FieldReader &reader, LogicalType type) {
 	D_ASSERT(type.InternalType() == PhysicalType::LIST);
 	auto result = make_unique<ListStatistics>(move(type));
 	auto &child_type = ListType::GetChildType(result->type);
+	auto &source = reader.GetSource();
 	result->child_stats = BaseStatistics::Deserialize(source, child_type);
 	return move(result);
 }
 
-string ListStatistics::ToString() {
+string ListStatistics::ToString() const {
 	string result;
 	result += " [";
 	result += child_stats ? child_stats->ToString() : "No Stats";
@@ -161540,7 +161980,7 @@ string ListStatistics::ToString() {
 	return result;
 }
 
-void ListStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t count) {
+void ListStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t count) const {
 	BaseStatistics::Verify(vector, sel, count);
 
 	if (child_stats) {
@@ -161582,6 +162022,7 @@ void ListStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t co
 
 
 
+
 namespace duckdb {
 
 template <>
@@ -161617,7 +162058,7 @@ void NumericStatistics::Merge(const BaseStatistics &other_p) {
 	}
 }
 
-FilterPropagateResult NumericStatistics::CheckZonemap(ExpressionType comparison_type, const Value &constant) {
+FilterPropagateResult NumericStatistics::CheckZonemap(ExpressionType comparison_type, const Value &constant) const {
 	if (constant.IsNull()) {
 		return FilterPropagateResult::FILTER_ALWAYS_FALSE;
 	}
@@ -161690,7 +162131,7 @@ FilterPropagateResult NumericStatistics::CheckZonemap(ExpressionType comparison_
 	}
 }
 
-unique_ptr<BaseStatistics> NumericStatistics::Copy() {
+unique_ptr<BaseStatistics> NumericStatistics::Copy() const {
 	auto stats = make_unique<NumericStatistics>(type, min, max);
 	if (validity_stats) {
 		stats->validity_stats = validity_stats->Copy();
@@ -161698,29 +162139,28 @@ unique_ptr<BaseStatistics> NumericStatistics::Copy() {
 	return move(stats);
 }
 
-bool NumericStatistics::IsConstant() {
+bool NumericStatistics::IsConstant() const {
 	return max <= min;
 }
 
-void NumericStatistics::Serialize(Serializer &serializer) {
-	BaseStatistics::Serialize(serializer);
-	min.Serialize(serializer);
-	max.Serialize(serializer);
+void NumericStatistics::Serialize(FieldWriter &writer) const {
+	writer.WriteSerializable(min);
+	writer.WriteSerializable(max);
 }
 
-unique_ptr<BaseStatistics> NumericStatistics::Deserialize(Deserializer &source, LogicalType type) {
-	auto min = Value::Deserialize(source);
-	auto max = Value::Deserialize(source);
+unique_ptr<BaseStatistics> NumericStatistics::Deserialize(FieldReader &reader, LogicalType type) {
+	auto min = reader.ReadRequiredSerializable<Value, Value>();
+	auto max = reader.ReadRequiredSerializable<Value, Value>();
 	return make_unique_base<BaseStatistics, NumericStatistics>(move(type), min, max);
 }
 
-string NumericStatistics::ToString() {
+string NumericStatistics::ToString() const {
 	return StringUtil::Format("[Min: %s, Max: %s]%s", min.ToString(), max.ToString(),
 	                          validity_stats ? validity_stats->ToString() : "");
 }
 
 template <class T>
-void NumericStatistics::TemplatedVerify(Vector &vector, const SelectionVector &sel, idx_t count) {
+void NumericStatistics::TemplatedVerify(Vector &vector, const SelectionVector &sel, idx_t count) const {
 	VectorData vdata;
 	vector.Orrify(count, vdata);
 
@@ -161742,7 +162182,7 @@ void NumericStatistics::TemplatedVerify(Vector &vector, const SelectionVector &s
 	}
 }
 
-void NumericStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t count) {
+void NumericStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t count) const {
 	BaseStatistics::Verify(vector, sel, count);
 
 	switch (type.InternalType()) {
@@ -161831,7 +162271,7 @@ StringStatistics::StringStatistics(LogicalType type_p) : BaseStatistics(move(typ
 	validity_stats = make_unique<ValidityStatistics>(false);
 }
 
-unique_ptr<BaseStatistics> StringStatistics::Copy() {
+unique_ptr<BaseStatistics> StringStatistics::Copy() const {
 	auto stats = make_unique<StringStatistics>(type);
 	memcpy(stats->min, min, MAX_STRING_MINMAX_SIZE);
 	memcpy(stats->max, max, MAX_STRING_MINMAX_SIZE);
@@ -161843,22 +162283,21 @@ unique_ptr<BaseStatistics> StringStatistics::Copy() {
 	return move(stats);
 }
 
-void StringStatistics::Serialize(Serializer &serializer) {
-	BaseStatistics::Serialize(serializer);
-	serializer.WriteData(min, MAX_STRING_MINMAX_SIZE);
-	serializer.WriteData(max, MAX_STRING_MINMAX_SIZE);
-	serializer.Write<bool>(has_unicode);
-	serializer.Write<uint32_t>(max_string_length);
-	serializer.Write<bool>(has_overflow_strings);
+void StringStatistics::Serialize(FieldWriter &writer) const {
+	writer.WriteBlob(min, MAX_STRING_MINMAX_SIZE);
+	writer.WriteBlob(max, MAX_STRING_MINMAX_SIZE);
+	writer.WriteField<bool>(has_unicode);
+	writer.WriteField<uint32_t>(max_string_length);
+	writer.WriteField<bool>(has_overflow_strings);
 }
 
-unique_ptr<BaseStatistics> StringStatistics::Deserialize(Deserializer &source, LogicalType type) {
+unique_ptr<BaseStatistics> StringStatistics::Deserialize(FieldReader &reader, LogicalType type) {
 	auto stats = make_unique<StringStatistics>(move(type));
-	source.ReadData(stats->min, MAX_STRING_MINMAX_SIZE);
-	source.ReadData(stats->max, MAX_STRING_MINMAX_SIZE);
-	stats->has_unicode = source.Read<bool>();
-	stats->max_string_length = source.Read<uint32_t>();
-	stats->has_overflow_strings = source.Read<bool>();
+	reader.ReadBlob(stats->min, MAX_STRING_MINMAX_SIZE);
+	reader.ReadBlob(stats->max, MAX_STRING_MINMAX_SIZE);
+	stats->has_unicode = reader.ReadRequired<bool>();
+	stats->max_string_length = reader.ReadRequired<uint32_t>();
+	stats->has_overflow_strings = reader.ReadRequired<bool>();
 	return move(stats);
 }
 
@@ -161926,7 +162365,7 @@ void StringStatistics::Merge(const BaseStatistics &other_p) {
 	has_overflow_strings = has_overflow_strings || other.has_overflow_strings;
 }
 
-FilterPropagateResult StringStatistics::CheckZonemap(ExpressionType comparison_type, const string &constant) {
+FilterPropagateResult StringStatistics::CheckZonemap(ExpressionType comparison_type, const string &constant) const {
 	auto data = (const_data_ptr_t)constant.c_str();
 	auto size = constant.size();
 
@@ -161964,7 +162403,7 @@ FilterPropagateResult StringStatistics::CheckZonemap(ExpressionType comparison_t
 	}
 }
 
-static idx_t GetValidMinMaxSubstring(data_ptr_t data) {
+static idx_t GetValidMinMaxSubstring(const_data_ptr_t data) {
 	for (idx_t i = 0; i < StringStatistics::MAX_STRING_MINMAX_SIZE; i++) {
 		if (data[i] == '\0') {
 			return i;
@@ -161976,7 +162415,7 @@ static idx_t GetValidMinMaxSubstring(data_ptr_t data) {
 	return StringStatistics::MAX_STRING_MINMAX_SIZE;
 }
 
-string StringStatistics::ToString() {
+string StringStatistics::ToString() const {
 	idx_t min_len = GetValidMinMaxSubstring(min);
 	idx_t max_len = GetValidMinMaxSubstring(max);
 	return StringUtil::Format("[Min: %s, Max: %s, Has Unicode: %s, Max String Length: %lld]%s",
@@ -161985,7 +162424,7 @@ string StringStatistics::ToString() {
 	                          validity_stats ? validity_stats->ToString() : "");
 }
 
-void StringStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t count) {
+void StringStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t count) const {
 	BaseStatistics::Verify(vector, sel, count);
 
 	string_t min_string((const char *)min, MAX_STRING_MINMAX_SIZE);
@@ -162064,12 +162503,12 @@ void StructStatistics::Merge(const BaseStatistics &other_p) {
 }
 
 // LCOV_EXCL_START
-FilterPropagateResult StructStatistics::CheckZonemap(ExpressionType comparison_type, const Value &constant) {
+FilterPropagateResult StructStatistics::CheckZonemap(ExpressionType comparison_type, const Value &constant) const {
 	throw InternalException("Struct zonemaps are not supported yet");
 }
 // LCOV_EXCL_STOP
 
-unique_ptr<BaseStatistics> StructStatistics::Copy() {
+unique_ptr<BaseStatistics> StructStatistics::Copy() const {
 	auto copy = make_unique<StructStatistics>(type);
 	if (validity_stats) {
 		copy->validity_stats = validity_stats->Copy();
@@ -162080,8 +162519,9 @@ unique_ptr<BaseStatistics> StructStatistics::Copy() {
 	return move(copy);
 }
 
-void StructStatistics::Serialize(Serializer &serializer) {
-	BaseStatistics::Serialize(serializer);
+void StructStatistics::Serialize(FieldWriter &writer) const {
+	writer.WriteField<uint32_t>(child_stats.size());
+	auto &serializer = writer.GetSerializer();
 	for (idx_t i = 0; i < child_stats.size(); i++) {
 		serializer.Write<bool>(child_stats[i] ? true : false);
 		if (child_stats[i]) {
@@ -162090,10 +162530,16 @@ void StructStatistics::Serialize(Serializer &serializer) {
 	}
 }
 
-unique_ptr<BaseStatistics> StructStatistics::Deserialize(Deserializer &source, LogicalType type) {
+unique_ptr<BaseStatistics> StructStatistics::Deserialize(FieldReader &reader, LogicalType type) {
 	D_ASSERT(type.InternalType() == PhysicalType::STRUCT);
 	auto result = make_unique<StructStatistics>(move(type));
 	auto &child_types = StructType::GetChildTypes(result->type);
+
+	auto child_type_count = reader.ReadRequired<uint32_t>();
+	if (child_types.size() != child_type_count) {
+		throw InternalException("Struct stats deserialization failure: child count does not match type count!");
+	}
+	auto &source = reader.GetSource();
 	for (idx_t i = 0; i < child_types.size(); i++) {
 		auto has_child = source.Read<bool>();
 		if (has_child) {
@@ -162105,7 +162551,7 @@ unique_ptr<BaseStatistics> StructStatistics::Deserialize(Deserializer &source, L
 	return move(result);
 }
 
-string StructStatistics::ToString() {
+string StructStatistics::ToString() const {
 	string result;
 	result += " {";
 	auto &child_types = StructType::GetChildTypes(type);
@@ -162120,7 +162566,7 @@ string StructStatistics::ToString() {
 	return result;
 }
 
-void StructStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t count) {
+void StructStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t count) const {
 	BaseStatistics::Verify(vector, sel, count);
 
 	auto &child_entries = StructVector::GetEntries(vector);
@@ -162158,7 +162604,7 @@ unique_ptr<BaseStatistics> ValidityStatistics::Combine(const unique_ptr<BaseStat
 	}
 }
 
-bool ValidityStatistics::IsConstant() {
+bool ValidityStatistics::IsConstant() const {
 	if (!has_null) {
 		return true;
 	}
@@ -162174,23 +162620,22 @@ void ValidityStatistics::Merge(const BaseStatistics &other_p) {
 	has_no_null = has_no_null || other.has_no_null;
 }
 
-unique_ptr<BaseStatistics> ValidityStatistics::Copy() {
+unique_ptr<BaseStatistics> ValidityStatistics::Copy() const {
 	return make_unique<ValidityStatistics>(has_null, has_no_null);
 }
 
-void ValidityStatistics::Serialize(Serializer &serializer) {
-	BaseStatistics::Serialize(serializer);
-	serializer.Write<bool>(has_null);
-	serializer.Write<bool>(has_no_null);
+void ValidityStatistics::Serialize(FieldWriter &writer) const {
+	writer.WriteField<bool>(has_null);
+	writer.WriteField<bool>(has_no_null);
 }
 
-unique_ptr<BaseStatistics> ValidityStatistics::Deserialize(Deserializer &source) {
-	bool has_null = source.Read<bool>();
-	bool has_no_null = source.Read<bool>();
+unique_ptr<BaseStatistics> ValidityStatistics::Deserialize(FieldReader &reader) {
+	bool has_null = reader.ReadRequired<bool>();
+	bool has_no_null = reader.ReadRequired<bool>();
 	return make_unique<ValidityStatistics>(has_null, has_no_null);
 }
 
-void ValidityStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t count) {
+void ValidityStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t count) const {
 	if (has_null && has_no_null) {
 		// nothing to verify
 		return;
@@ -162214,7 +162659,7 @@ void ValidityStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_
 	}
 }
 
-string ValidityStatistics::ToString() {
+string ValidityStatistics::ToString() const {
 	return has_null ? "[Has Null: true]" : "[Has Null: false]";
 }
 
@@ -164673,6 +165118,7 @@ PersistentTableData::~PersistentTableData() {
 
 
 
+
 namespace duckdb {
 
 constexpr const idx_t RowGroup::ROW_GROUP_VECTOR_COUNT;
@@ -165390,9 +165836,11 @@ shared_ptr<VersionNode> RowGroup::DeserializeDeletes(Deserializer &source) {
 	return version_info;
 }
 
-void RowGroup::Serialize(RowGroupPointer &pointer, Serializer &serializer) {
-	serializer.Write<uint64_t>(pointer.row_start);
-	serializer.Write<uint64_t>(pointer.tuple_count);
+void RowGroup::Serialize(RowGroupPointer &pointer, Serializer &main_serializer) {
+	FieldWriter writer(main_serializer);
+	writer.WriteField<uint64_t>(pointer.row_start);
+	writer.WriteField<uint64_t>(pointer.tuple_count);
+	auto &serializer = writer.GetSerializer();
 	for (auto &stats : pointer.statistics) {
 		stats->Serialize(serializer);
 	}
@@ -165401,16 +165849,20 @@ void RowGroup::Serialize(RowGroupPointer &pointer, Serializer &serializer) {
 		serializer.Write<uint64_t>(data_pointer.offset);
 	}
 	CheckpointDeletes(pointer.versions.get(), serializer);
+	writer.Finalize();
 }
 
-RowGroupPointer RowGroup::Deserialize(Deserializer &source, const vector<ColumnDefinition> &columns) {
+RowGroupPointer RowGroup::Deserialize(Deserializer &main_source, const vector<ColumnDefinition> &columns) {
 	RowGroupPointer result;
-	result.row_start = source.Read<uint64_t>();
-	result.tuple_count = source.Read<uint64_t>();
+
+	FieldReader reader(main_source);
+	result.row_start = reader.ReadRequired<uint64_t>();
+	result.tuple_count = reader.ReadRequired<uint64_t>();
 
 	result.data_pointers.reserve(columns.size());
 	result.statistics.reserve(columns.size());
 
+	auto &source = reader.GetSource();
 	for (idx_t i = 0; i < columns.size(); i++) {
 		auto stats = BaseStatistics::Deserialize(source, columns[i].type);
 		result.statistics.push_back(move(stats));
@@ -165422,6 +165874,8 @@ RowGroupPointer RowGroup::Deserialize(Deserializer &source, const vector<ColumnD
 		result.data_pointers.push_back(pointer);
 	}
 	result.versions = DeserializeDeletes(source);
+
+	reader.Finalize();
 	return result;
 }
 
@@ -167384,8 +167838,11 @@ bool ValidityColumnData::CheckZonemap(ColumnScanState &state, TableFilter &filte
 
 
 
+
+
 
 namespace duckdb {
+
 class ReplayState {
 public:
 	ReplayState(DatabaseInstance &db, ClientContext &context, Deserializer &source)
@@ -167681,18 +168138,13 @@ void ReplayState::ReplayDropSchema() {
 // Replay Custom Type
 //===--------------------------------------------------------------------===//
 void ReplayState::ReplayCreateType() {
-	CreateTypeInfo info;
-
-	info.schema = source.Read<string>();
-	info.name = source.Read<string>();
-	info.type = make_unique<LogicalType>(LogicalType::Deserialize(source));
-
+	auto info = TypeCatalogEntry::Deserialize(source);
 	if (deserialize_only) {
 		return;
 	}
 
 	auto &catalog = Catalog::GetCatalog(context);
-	catalog.CreateType(context, &info);
+	catalog.CreateType(context, info.get());
 }
 
 void ReplayState::ReplayDropType() {