duckdb 0.8.2-dev4126.0 → 0.8.2-dev4203.0

package/src/duckdb/src/parser/parsed_data/create_copy_function_info.cpp

@@ -8,10 +8,6 @@ CreateCopyFunctionInfo::CreateCopyFunctionInfo(CopyFunction function_p)
 	internal = true;
 }
 
-void CreateCopyFunctionInfo::SerializeInternal(Serializer &) const {
-	throw NotImplementedException("Cannot serialize '%s'", CatalogTypeToString(type));
-}
-
 unique_ptr<CreateInfo> CreateCopyFunctionInfo::Copy() const {
 	auto result = make_uniq<CreateCopyFunctionInfo>(function);
 	CopyProperties(*result);

package/src/duckdb/src/parser/parsed_data/create_index_info.cpp

@@ -1,7 +1,5 @@
 #include "duckdb/parser/parsed_data/create_index_info.hpp"
 
-#include "duckdb/common/field_writer.hpp"
-
 namespace duckdb {
 
 unique_ptr<CreateInfo> CreateIndexInfo::Copy() const {
@@ -26,50 +24,4 @@ unique_ptr<CreateInfo> CreateIndexInfo::Copy() const {
 	return std::move(result);
 }
 
-void CreateIndexInfo::SerializeInternal(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField(index_type);
-	writer.WriteString(table);
-	writer.WriteString(index_name);
-	writer.WriteField(constraint_type);
-
-	writer.WriteSerializableList<ParsedExpression>(parsed_expressions);
-
-	writer.WriteRegularSerializableList(scan_types);
-	writer.WriteList<string>(names);
-	writer.WriteList<column_t>(column_ids);
-	writer.WriteString(index_type_name);
-	writer.WriteField((idx_t)options.size());
-	for (auto &kv : options) {
-		writer.WriteString(kv.first);
-		writer.WriteSerializable(kv.second);
-	}
-	writer.Finalize();
-}
-
-unique_ptr<CreateIndexInfo> CreateIndexInfo::Deserialize(Deserializer &deserializer) {
-	auto result = make_uniq<CreateIndexInfo>();
-	result->DeserializeBase(deserializer);
-
-	FieldReader reader(deserializer);
-	result->index_type = reader.ReadRequired<IndexType>();
-	result->table = reader.ReadRequired<string>();
-	result->index_name = reader.ReadRequired<string>();
-	result->constraint_type = reader.ReadRequired<IndexConstraintType>();
-
-	result->parsed_expressions = reader.ReadRequiredSerializableList<ParsedExpression>();
-
-	result->scan_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	result->names = reader.ReadRequiredList<string>();
-	result->column_ids = reader.ReadRequiredList<column_t>();
-	result->index_type_name = reader.ReadRequired<string>();
-	auto options_count = reader.ReadRequired<idx_t>();
-	for (idx_t i = 0; i < options_count; i++) {
-		auto key = reader.ReadRequired<string>();
-		auto value = reader.ReadRequiredSerializable<Value, Value>();
-		result->options[key] = value;
-	}
-	reader.Finalize();
-	return result;
-}
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/create_info.cpp

@@ -11,53 +11,6 @@
 
 namespace duckdb {
 
-void CreateInfo::Serialize(Serializer &serializer) const {
-	serializer.Write(type);
-	serializer.WriteString(catalog);
-	serializer.WriteString(schema);
-	serializer.Write(on_conflict);
-	serializer.Write(temporary);
-	serializer.Write(internal);
-	serializer.WriteString(sql);
-	SerializeInternal(serializer);
-}
-
-void CreateInfo::DeserializeBase(Deserializer &deserializer) {
-	this->catalog = deserializer.Read<string>();
-	this->schema = deserializer.Read<string>();
-	this->on_conflict = deserializer.Read<OnCreateConflict>();
-	this->temporary = deserializer.Read<bool>();
-	this->internal = deserializer.Read<bool>();
-	this->sql = deserializer.Read<string>();
-}
-
-unique_ptr<CreateInfo> CreateInfo::Deserialize(Deserializer &deserializer) {
-	auto type = deserializer.Read<CatalogType>();
-	switch (type) {
-	case CatalogType::INDEX_ENTRY:
-		return CreateIndexInfo::Deserialize(deserializer);
-	case CatalogType::TABLE_ENTRY:
-		return CreateTableInfo::Deserialize(deserializer);
-	case CatalogType::SCHEMA_ENTRY:
-		return CreateSchemaInfo::Deserialize(deserializer);
-	case CatalogType::VIEW_ENTRY:
-		return CreateViewInfo::Deserialize(deserializer);
-	case CatalogType::TYPE_ENTRY:
-		return CreateTypeInfo::Deserialize(deserializer);
-	case CatalogType::MACRO_ENTRY:
-	case CatalogType::TABLE_MACRO_ENTRY:
-		return CreateMacroInfo::Deserialize(deserializer);
-	case CatalogType::SEQUENCE_ENTRY:
-		return CreateSequenceInfo::Deserialize(deserializer);
-	default:
-		throw NotImplementedException("Cannot deserialize '%s'", CatalogTypeToString(type));
-	}
-}
-
-unique_ptr<CreateInfo> CreateInfo::Deserialize(Deserializer &source, PlanDeserializationState &state) {
-	return Deserialize(source);
-}
-
 void CreateInfo::CopyProperties(CreateInfo &other) const {
 	other.type = type;
 	other.catalog = catalog;

package/src/duckdb/src/parser/parsed_data/create_macro_info.cpp

@@ -5,42 +5,15 @@
 
 namespace duckdb {
 
-CreateMacroInfo::CreateMacroInfo() : CreateFunctionInfo(CatalogType::MACRO_ENTRY, INVALID_SCHEMA) {
-}
-
 CreateMacroInfo::CreateMacroInfo(CatalogType type) : CreateFunctionInfo(type, INVALID_SCHEMA) {
 }
 
 unique_ptr<CreateInfo> CreateMacroInfo::Copy() const {
-	auto result = make_uniq<CreateMacroInfo>();
+	auto result = make_uniq<CreateMacroInfo>(type);
 	result->function = function->Copy();
 	result->name = name;
 	CopyProperties(*result);
 	return std::move(result);
 }
 
-void CreateMacroInfo::SerializeInternal(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteString(name);
-	writer.WriteSerializable(*function);
-	writer.Finalize();
-}
-
-unique_ptr<CreateMacroInfo> CreateMacroInfo::Deserialize(Deserializer &deserializer) {
-	auto result = make_uniq<CreateMacroInfo>();
-	result->DeserializeBase(deserializer);
-
-	FieldReader reader(deserializer);
-	result->name = reader.ReadRequired<string>();
-	result->function = reader.ReadRequiredSerializable<MacroFunction>();
-	reader.Finalize();
-
-	if (result->function->type == MacroType::TABLE_MACRO) {
-		result->type = CatalogType::TABLE_MACRO_ENTRY;
-	} else {
-		result->type = CatalogType::MACRO_ENTRY;
-	}
-	return result;
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/create_sequence_info.cpp

@@ -24,35 +24,4 @@ unique_ptr<CreateInfo> CreateSequenceInfo::Copy() const {
 	return std::move(result);
 }
 
-void CreateSequenceInfo::SerializeInternal(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteString(name);
-	writer.WriteString(schema);
-	writer.WriteField(usage_count);
-	writer.WriteField(increment);
-	writer.WriteField(min_value);
-	writer.WriteField(max_value);
-	writer.WriteField(start_value);
-	writer.WriteField(cycle);
-	writer.Finalize();
-}
-
-unique_ptr<CreateSequenceInfo> CreateSequenceInfo::Deserialize(Deserializer &deserializer) {
-	auto result = make_uniq<CreateSequenceInfo>();
-	result->DeserializeBase(deserializer);
-
-	FieldReader reader(deserializer);
-	result->name = reader.ReadRequired<string>();
-	result->schema = reader.ReadRequired<string>();
-	result->usage_count = reader.ReadRequired<uint64_t>();
-	result->increment = reader.ReadRequired<int64_t>();
-	result->min_value = reader.ReadRequired<int64_t>();
-	result->max_value = reader.ReadRequired<int64_t>();
-	result->start_value = reader.ReadRequired<int64_t>();
-	result->cycle = reader.ReadRequired<bool>();
-	reader.Finalize();
-
-	return result;
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/create_table_info.cpp

@@ -16,29 +16,6 @@ CreateTableInfo::CreateTableInfo(SchemaCatalogEntry &schema, string name_p)
     : CreateTableInfo(schema.catalog.GetName(), schema.name, std::move(name_p)) {
 }
 
-void CreateTableInfo::SerializeInternal(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteString(table);
-	columns.Serialize(writer);
-	writer.WriteSerializableList(constraints);
-	writer.WriteOptional(query);
-	writer.Finalize();
-}
-
-unique_ptr<CreateTableInfo> CreateTableInfo::Deserialize(Deserializer &deserializer) {
-	auto result = make_uniq<CreateTableInfo>();
-	result->DeserializeBase(deserializer);
-
-	FieldReader reader(deserializer);
-	result->table = reader.ReadRequired<string>();
-	result->columns = ColumnList::Deserialize(reader);
-	result->constraints = reader.ReadRequiredSerializableList<Constraint>();
-	result->query = reader.ReadOptional<SelectStatement>(nullptr);
-	reader.Finalize();
-
-	return result;
-}
-
 unique_ptr<CreateInfo> CreateTableInfo::Copy() const {
 	auto result = make_uniq<CreateTableInfo>(catalog, schema, table);
 	CopyProperties(*result);

package/src/duckdb/src/parser/parsed_data/create_type_info.cpp

@@ -22,26 +22,4 @@ unique_ptr<CreateInfo> CreateTypeInfo::Copy() const {
 	return std::move(result);
 }
 
-void CreateTypeInfo::SerializeInternal(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteString(name);
-	writer.WriteSerializable(type);
-	if (query) {
-		throw InternalException("Cannot serialize CreateTypeInfo with query");
-	}
-	writer.Finalize();
-}
-
-unique_ptr<CreateTypeInfo> CreateTypeInfo::Deserialize(Deserializer &deserializer) {
-	auto result = make_uniq<CreateTypeInfo>();
-	result->DeserializeBase(deserializer);
-
-	FieldReader reader(deserializer);
-	result->name = reader.ReadRequired<string>();
-	result->type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	reader.Finalize();
-
-	return result;
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/create_view_info.cpp

@@ -28,29 +28,6 @@ unique_ptr<CreateInfo> CreateViewInfo::Copy() const {
 	return std::move(result);
 }
 
-unique_ptr<CreateViewInfo> CreateViewInfo::Deserialize(Deserializer &deserializer) {
-	auto result = make_uniq<CreateViewInfo>();
-	result->DeserializeBase(deserializer);
-
-	FieldReader reader(deserializer);
-	result->view_name = reader.ReadRequired<string>();
-	result->aliases = reader.ReadRequiredList<string>();
-	result->types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	result->query = reader.ReadOptional<SelectStatement>(nullptr);
-	reader.Finalize();
-
-	return result;
-}
-
-void CreateViewInfo::SerializeInternal(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteString(view_name);
-	writer.WriteList<string>(aliases);
-	writer.WriteRegularSerializableList(types);
-	writer.WriteOptional(query);
-	writer.Finalize();
-}
-
 unique_ptr<CreateViewInfo> CreateViewInfo::FromSelect(ClientContext &context, unique_ptr<CreateViewInfo> info) {
 	D_ASSERT(info);
 	D_ASSERT(!info->view_name.empty());

package/src/duckdb/src/parser/parsed_data/detach_info.cpp

@@ -1,5 +1,4 @@
 #include "duckdb/parser/parsed_data/detach_info.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
@@ -13,22 +12,4 @@ unique_ptr<DetachInfo> DetachInfo::Copy() const {
 	return result;
 }
 
-void DetachInfo::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteString(name);
-	writer.WriteField(if_not_found);
-	writer.Finalize();
-}
-
-unique_ptr<ParseInfo> DetachInfo::Deserialize(Deserializer &deserializer) {
-	auto result = make_uniq<DetachInfo>();
-
-	FieldReader reader(deserializer);
-	result->name = reader.ReadRequired<string>();
-	result->if_not_found = reader.ReadRequired<OnEntryNotFound>();
-	reader.Finalize();
-
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/drop_info.cpp

@@ -17,30 +17,4 @@ unique_ptr<DropInfo> DropInfo::Copy() const {
 	return result;
 }
 
-void DropInfo::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField<CatalogType>(type);
-	writer.WriteString(catalog);
-	writer.WriteString(schema);
-	writer.WriteString(name);
-	writer.WriteField(if_not_found);
-	writer.WriteField(cascade);
-	writer.WriteField(allow_drop_internal);
-	writer.Finalize();
-}
-
-unique_ptr<ParseInfo> DropInfo::Deserialize(Deserializer &deserializer) {
-	FieldReader reader(deserializer);
-	auto drop_info = make_uniq<DropInfo>();
-	drop_info->type = reader.ReadRequired<CatalogType>();
-	drop_info->catalog = reader.ReadRequired<string>();
-	drop_info->schema = reader.ReadRequired<string>();
-	drop_info->name = reader.ReadRequired<string>();
-	drop_info->if_not_found = reader.ReadRequired<OnEntryNotFound>();
-	drop_info->cascade = reader.ReadRequired<bool>();
-	drop_info->allow_drop_internal = reader.ReadRequired<bool>();
-	reader.Finalize();
-	return std::move(drop_info);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/sample_options.cpp

@@ -1,7 +1,6 @@
 #include "duckdb/parser/parsed_data/sample_options.hpp"
-#include "duckdb/common/field_writer.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -10,28 +9,6 @@ string SampleMethodToString(SampleMethod method) {
 	return EnumUtil::ToString(method);
 }
 
-void SampleOptions::Serialize(Serializer &serializer) {
-	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_uniq<SampleOptions>();
-
-	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;
-}
-
 unique_ptr<SampleOptions> SampleOptions::Copy() {
 	auto result = make_uniq<SampleOptions>();
 	result->sample_size = sample_size;

package/src/duckdb/src/parser/parsed_data/transaction_info.cpp

@@ -1,5 +1,4 @@
 #include "duckdb/parser/parsed_data/transaction_info.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
@@ -9,19 +8,4 @@ TransactionInfo::TransactionInfo() : ParseInfo(TYPE) {
 TransactionInfo::TransactionInfo(TransactionType type) : ParseInfo(TYPE), type(type) {
 }
 
-void TransactionInfo::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField(type);
-	writer.Finalize();
-}
-
-unique_ptr<ParseInfo> TransactionInfo::Deserialize(Deserializer &deserializer) {
-	FieldReader reader(deserializer);
-	auto transaction_type = reader.ReadRequired<TransactionType>();
-	reader.Finalize();
-
-	auto transaction_info = make_uniq<TransactionInfo>(transaction_type);
-	return std::move(transaction_info);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/vacuum_info.cpp

@@ -1,5 +1,4 @@
 #include "duckdb/parser/parsed_data/vacuum_info.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
@@ -15,23 +14,4 @@ unique_ptr<VacuumInfo> VacuumInfo::Copy() {
 	return result;
 }
 
-void VacuumInfo::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField(options.analyze);
-	writer.WriteField(options.vacuum);
-	writer.Finalize();
-}
-
-unique_ptr<ParseInfo> VacuumInfo::Deserialize(Deserializer &deserializer) {
-
-	VacuumOptions options;
-	FieldReader reader(deserializer);
-	options.analyze = reader.ReadRequired<bool>();
-	options.vacuum = reader.ReadRequired<bool>();
-	reader.Finalize();
-
-	auto vacuum_info = make_uniq<VacuumInfo>(options);
-	return std::move(vacuum_info);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_expression.cpp

@@ -1,12 +1,11 @@
 #include "duckdb/main/client_context.hpp"
 
 #include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/parser/expression/list.hpp"
 #include "duckdb/parser/parsed_expression_iterator.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 #include "duckdb/parser/expression_util.hpp"
 
 namespace duckdb {
@@ -101,82 +100,6 @@ hash_t ParsedExpression::Hash() const {
 	return hash;
 }
 
-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) {
-	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, reader);
-		break;
-	case ExpressionClass::CASE:
-		result = CaseExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::CAST:
-		result = CastExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::COLLATE:
-		result = CollateExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::COLUMN_REF:
-		result = ColumnRefExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::COMPARISON:
-		result = ComparisonExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::CONJUNCTION:
-		result = ConjunctionExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::CONSTANT:
-		result = ConstantExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::DEFAULT:
-		result = DefaultExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::FUNCTION:
-		result = FunctionExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::LAMBDA:
-		result = LambdaExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::OPERATOR:
-		result = OperatorExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::PARAMETER:
-		result = ParameterExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::POSITIONAL_REFERENCE:
-		result = PositionalReferenceExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::STAR:
-		result = StarExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::SUBQUERY:
-		result = SubqueryExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::WINDOW:
-		result = WindowExpression::Deserialize(type, reader);
-		break;
-	default:
-		throw SerializationException("Unsupported type for expression deserialization: '%s'!",
-		                             ExpressionClassToString(expression_class));
-	}
-	result->alias = alias;
-	reader.Finalize();
-	return result;
-}
-
 bool ParsedExpression::Equals(const unique_ptr<ParsedExpression> &left, const unique_ptr<ParsedExpression> &right) {
 	if (left.get() == right.get()) {
 		return true;

package/src/duckdb/src/parser/query_node/cte_node.cpp

@@ -1,7 +1,6 @@
 #include "duckdb/parser/query_node/cte_node.hpp"
-#include "duckdb/common/field_writer.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -39,20 +38,4 @@ unique_ptr<QueryNode> CTENode::Copy() const {
 	return std::move(result);
 }
 
-void CTENode::Serialize(FieldWriter &writer) const {
-	writer.WriteString(ctename);
-	writer.WriteSerializable(*query);
-	writer.WriteSerializable(*child);
-	writer.WriteList<string>(aliases);
-}
-
-unique_ptr<QueryNode> CTENode::Deserialize(FieldReader &reader) {
-	auto result = make_uniq<CTENode>();
-	result->ctename = reader.ReadRequired<string>();
-	result->query = reader.ReadRequiredSerializable<QueryNode>();
-	result->child = reader.ReadRequiredSerializable<QueryNode>();
-	result->aliases = reader.ReadRequiredList<string>();
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/query_node/recursive_cte_node.cpp

@@ -1,7 +1,6 @@
 #include "duckdb/parser/query_node/recursive_cte_node.hpp"
-#include "duckdb/common/field_writer.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -48,22 +47,4 @@ unique_ptr<QueryNode> RecursiveCTENode::Copy() const {
 	return std::move(result);
 }
 
-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(FieldReader &reader) {
-	auto result = make_uniq<RecursiveCTENode>();
-	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 std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/query_node/select_node.cpp

@@ -1,9 +1,8 @@
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/expression_util.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/keyword_helper.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -168,48 +167,4 @@ unique_ptr<QueryNode> SelectNode::Copy() const {
 	return std::move(result);
 }
 
-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);
-		}
-	}
-	writer.WriteField<AggregateHandling>(aggregate_handling);
-	writer.WriteOptional(having);
-	writer.WriteOptional(sample);
-	writer.WriteOptional(qualify);
-}
-
-unique_ptr<QueryNode> SelectNode::Deserialize(FieldReader &reader) {
-	auto result = make_uniq<SelectNode>();
-	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;
-		for (idx_t i = 0; i < set_entries; i++) {
-			grouping_set.insert(source.Read<idx_t>());
-		}
-		result->groups.grouping_sets.push_back(grouping_set);
-	}
-
-	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 std::move(result);
-}
-
 } // namespace duckdb