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

package/src/duckdb/src/parser/constraints/foreign_key_constraint.cpp

@@ -1,6 +1,5 @@
 #include "duckdb/parser/constraints/foreign_key_constraint.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/limits.hpp"
 #include "duckdb/parser/keyword_helper.hpp"
 
@@ -50,30 +49,4 @@ unique_ptr<Constraint> ForeignKeyConstraint::Copy() const {
 	return make_uniq<ForeignKeyConstraint>(pk_columns, fk_columns, info);
 }
 
-void ForeignKeyConstraint::Serialize(FieldWriter &writer) const {
-	D_ASSERT(pk_columns.size() <= NumericLimits<uint32_t>::Maximum());
-	writer.WriteList<string>(pk_columns);
-	D_ASSERT(fk_columns.size() <= NumericLimits<uint32_t>::Maximum());
-	writer.WriteList<string>(fk_columns);
-	writer.WriteField<ForeignKeyType>(info.type);
-	writer.WriteString(info.schema);
-	writer.WriteString(info.table);
-	writer.WriteIndexList<PhysicalIndex>(info.pk_keys);
-	writer.WriteIndexList<PhysicalIndex>(info.fk_keys);
-}
-
-unique_ptr<Constraint> ForeignKeyConstraint::Deserialize(FieldReader &source) {
-	ForeignKeyInfo read_info;
-	auto pk_columns = source.ReadRequiredList<string>();
-	auto fk_columns = source.ReadRequiredList<string>();
-	read_info.type = source.ReadRequired<ForeignKeyType>();
-	read_info.schema = source.ReadRequired<string>();
-	read_info.table = source.ReadRequired<string>();
-	read_info.pk_keys = source.ReadRequiredIndexList<PhysicalIndex>();
-	read_info.fk_keys = source.ReadRequiredIndexList<PhysicalIndex>();
-
-	// column list parsed constraint
-	return make_uniq<ForeignKeyConstraint>(pk_columns, fk_columns, std::move(read_info));
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/constraints/not_null_constraint.cpp

@@ -1,7 +1,5 @@
 #include "duckdb/parser/constraints/not_null_constraint.hpp"
 
-#include "duckdb/common/field_writer.hpp"
-
 namespace duckdb {
 
 NotNullConstraint::NotNullConstraint(LogicalIndex index) : Constraint(ConstraintType::NOT_NULL), index(index) {
@@ -18,13 +16,4 @@ unique_ptr<Constraint> NotNullConstraint::Copy() const {
 	return make_uniq<NotNullConstraint>(index);
 }
 
-void NotNullConstraint::Serialize(FieldWriter &writer) const {
-	writer.WriteField<idx_t>(index.index);
-}
-
-unique_ptr<Constraint> NotNullConstraint::Deserialize(FieldReader &source) {
-	auto index = source.ReadRequired<idx_t>();
-	return make_uniq_base<Constraint, NotNullConstraint>(LogicalIndex(index));
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/constraints/unique_constraint.cpp

@@ -1,6 +1,5 @@
 #include "duckdb/parser/constraints/unique_constraint.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/limits.hpp"
 #include "duckdb/parser/keyword_helper.hpp"
 
@@ -38,27 +37,4 @@ unique_ptr<Constraint> UniqueConstraint::Copy() const {
 	}
 }
 
-void UniqueConstraint::Serialize(FieldWriter &writer) const {
-	writer.WriteField<bool>(is_primary_key);
-	writer.WriteField<uint64_t>(index.index);
-	D_ASSERT(columns.size() <= NumericLimits<uint32_t>::Maximum());
-	writer.WriteList<string>(columns);
-}
-
-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
-		auto result = make_uniq<UniqueConstraint>(LogicalIndex(index), is_primary_key);
-		result->columns = std::move(columns);
-		return std::move(result);
-	} else {
-		// column list parsed constraint
-		return make_uniq<UniqueConstraint>(std::move(columns), is_primary_key);
-	}
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/between_expression.cpp

@@ -1,7 +1,6 @@
 #include "duckdb/parser/expression/between_expression.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 {
 
@@ -37,17 +36,4 @@ unique_ptr<ParsedExpression> BetweenExpression::Copy() const {
 	return std::move(copy);
 }
 
-void BetweenExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*input);
-	writer.WriteSerializable(*lower);
-	writer.WriteSerializable(*upper);
-}
-
-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_uniq<BetweenExpression>(std::move(input), std::move(lower), std::move(upper));
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/case_expression.cpp

@@ -1,10 +1,9 @@
 #include "duckdb/parser/expression/case_expression.hpp"
 
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
 
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -46,30 +45,4 @@ unique_ptr<ParsedExpression> CaseExpression::Copy() const {
 	return std::move(copy);
 }
 
-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);
-	}
-	writer.WriteSerializable<ParsedExpression>(*else_expr);
-}
-
-unique_ptr<ParsedExpression> CaseExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto result = make_uniq<CaseExpression>();
-	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(std::move(new_check));
-	}
-	result->else_expr = reader.ReadRequiredSerializable<ParsedExpression>();
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/cast_expression.cpp

@@ -1,10 +1,9 @@
 #include "duckdb/parser/expression/cast_expression.hpp"
 
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
 
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -41,17 +40,4 @@ unique_ptr<ParsedExpression> CastExpression::Copy() const {
 	return std::move(copy);
 }
 
-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, FieldReader &reader) {
-	auto child = reader.ReadRequiredSerializable<ParsedExpression>();
-	auto cast_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	auto try_cast = reader.ReadRequired<bool>();
-	return make_uniq_base<ParsedExpression, CastExpression>(cast_type, std::move(child), try_cast);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/collate_expression.cpp

@@ -1,10 +1,9 @@
 #include "duckdb/parser/expression/collate_expression.hpp"
 
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
 
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -37,15 +36,4 @@ unique_ptr<ParsedExpression> CollateExpression::Copy() const {
 	return std::move(copy);
 }
 
-void CollateExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*child);
-	writer.WriteString(collation);
-}
-
-unique_ptr<ParsedExpression> CollateExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto child = reader.ReadRequiredSerializable<ParsedExpression>();
-	auto collation = reader.ReadRequired<string>();
-	return make_uniq_base<ParsedExpression, CollateExpression>(collation, std::move(child));
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/columnref_expression.cpp

@@ -1,12 +1,11 @@
 #include "duckdb/parser/expression/columnref_expression.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/parser/qualified_name.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 {
 
@@ -93,14 +92,4 @@ unique_ptr<ParsedExpression> ColumnRefExpression::Copy() const {
 	return std::move(copy);
 }
 
-void ColumnRefExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteList<string>(column_names);
-}
-
-unique_ptr<ParsedExpression> ColumnRefExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto column_names = reader.ReadRequiredList<string>();
-	auto expression = make_uniq<ColumnRefExpression>(std::move(column_names));
-	return std::move(expression);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/comparison_expression.cpp

@@ -1,11 +1,10 @@
 #include "duckdb/parser/expression/comparison_expression.hpp"
 
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/expression/cast_expression.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 {
 
@@ -37,15 +36,4 @@ unique_ptr<ParsedExpression> ComparisonExpression::Copy() const {
 	return std::move(copy);
 }
 
-void ComparisonExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*left);
-	writer.WriteSerializable(*right);
-}
-
-unique_ptr<ParsedExpression> ComparisonExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto left_child = reader.ReadRequiredSerializable<ParsedExpression>();
-	auto right_child = reader.ReadRequiredSerializable<ParsedExpression>();
-	return make_uniq<ComparisonExpression>(type, std::move(left_child), std::move(right_child));
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/conjunction_expression.cpp

@@ -1,10 +1,9 @@
 #include "duckdb/parser/expression/conjunction_expression.hpp"
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/expression_util.hpp"
 
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -58,14 +57,4 @@ unique_ptr<ParsedExpression> ConjunctionExpression::Copy() const {
 	return std::move(copy);
 }
 
-void ConjunctionExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializableList(children);
-}
-
-unique_ptr<ParsedExpression> ConjunctionExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto result = make_uniq<ConjunctionExpression>(type);
-	result->children = reader.ReadRequiredSerializableList<ParsedExpression>();
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/constant_expression.cpp

@@ -1,12 +1,11 @@
 #include "duckdb/parser/expression/constant_expression.hpp"
 
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/common/value_operations/value_operations.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 {
 
@@ -35,13 +34,4 @@ unique_ptr<ParsedExpression> ConstantExpression::Copy() const {
 	return std::move(copy);
 }
 
-void ConstantExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(value);
-}
-
-unique_ptr<ParsedExpression> ConstantExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	Value value = reader.ReadRequiredSerializable<Value, Value>();
-	return make_uniq<ConstantExpression>(std::move(value));
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/default_expression.cpp

@@ -2,8 +2,8 @@
 
 #include "duckdb/common/exception.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 {
 
@@ -20,11 +20,4 @@ unique_ptr<ParsedExpression> DefaultExpression::Copy() const {
 	return std::move(copy);
 }
 
-void DefaultExpression::Serialize(FieldWriter &writer) const {
-}
-
-unique_ptr<ParsedExpression> DefaultExpression::Deserialize(ExpressionType type, FieldReader &source) {
-	return make_uniq<DefaultExpression>();
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/function_expression.cpp

@@ -3,11 +3,10 @@
 #include <utility>
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/types/hash.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 {
 
@@ -92,35 +91,6 @@ unique_ptr<ParsedExpression> FunctionExpression::Copy() const {
 	return std::move(copy);
 }
 
-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);
-	writer.WriteField<bool>(export_state);
-	writer.WriteString(catalog);
-}
-
-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>();
-	auto export_state = reader.ReadField<bool>(false);
-	auto catalog = reader.ReadField<string>(INVALID_CATALOG);
-
-	unique_ptr<FunctionExpression> function;
-	function = make_uniq<FunctionExpression>(catalog, schema, function_name, std::move(children), std::move(filter),
-	                                         std::move(order_bys), distinct, is_operator, export_state);
-	return std::move(function);
-}
-
 void FunctionExpression::Verify() const {
 	D_ASSERT(!function_name.empty());
 }

package/src/duckdb/src/parser/expression/lambda_expression.cpp

@@ -1,10 +1,9 @@
 #include "duckdb/parser/expression/lambda_expression.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/common/string_util.hpp"
 
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -36,15 +35,4 @@ unique_ptr<ParsedExpression> LambdaExpression::Copy() const {
 	return std::move(copy);
 }
 
-void LambdaExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*lhs);
-	writer.WriteSerializable(*expr);
-}
-
-unique_ptr<ParsedExpression> LambdaExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto lhs = reader.ReadRequiredSerializable<ParsedExpression>();
-	auto expr = reader.ReadRequiredSerializable<ParsedExpression>();
-	return make_uniq<LambdaExpression>(std::move(lhs), std::move(expr));
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/operator_expression.cpp

@@ -1,10 +1,9 @@
 #include "duckdb/parser/expression/operator_expression.hpp"
 
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
 
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -48,14 +47,4 @@ unique_ptr<ParsedExpression> OperatorExpression::Copy() const {
 	return std::move(copy);
 }
 
-void OperatorExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializableList(children);
-}
-
-unique_ptr<ParsedExpression> OperatorExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto expression = make_uniq<OperatorExpression>(type);
-	expression->children = reader.ReadRequiredSerializableList<ParsedExpression>();
-	return std::move(expression);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/parameter_expression.cpp

@@ -1,12 +1,11 @@
 #include "duckdb/parser/expression/parameter_expression.hpp"
 
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/common/to_string.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 {
 
@@ -34,14 +33,4 @@ hash_t ParameterExpression::Hash() const {
 	return CombineHash(duckdb::Hash(identifier.c_str(), identifier.size()), result);
 }
 
-void ParameterExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteString(identifier);
-}
-
-unique_ptr<ParsedExpression> ParameterExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto expression = make_uniq<ParameterExpression>();
-	expression->identifier = reader.ReadRequired<string>();
-	return std::move(expression);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/positional_reference_expression.cpp

@@ -1,12 +1,11 @@
 #include "duckdb/parser/expression/positional_reference_expression.hpp"
 
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/common/to_string.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 {
 
@@ -38,13 +37,4 @@ hash_t PositionalReferenceExpression::Hash() const {
 	return CombineHash(duckdb::Hash(index), result);
 }
 
-void PositionalReferenceExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteField<idx_t>(index);
-}
-
-unique_ptr<ParsedExpression> PositionalReferenceExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto expression = make_uniq<PositionalReferenceExpression>(reader.ReadRequired<idx_t>());
-	return std::move(expression);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/star_expression.cpp

@@ -1,10 +1,9 @@
 #include "duckdb/parser/expression/star_expression.hpp"
 
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
 
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -79,46 +78,6 @@ bool StarExpression::Equal(const StarExpression &a, const StarExpression &b) {
 	return true;
 }
 
-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);
-	}
-	writer.WriteField<uint32_t>(replace_list.size());
-	for (auto &entry : replace_list) {
-		serializer.WriteString(entry.first);
-		entry.second->Serialize(serializer);
-	}
-	writer.WriteField<bool>(columns);
-	writer.WriteOptional(expr);
-}
-
-unique_ptr<ParsedExpression> StarExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto &source = reader.GetSource();
-
-	auto result = make_uniq<StarExpression>();
-	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 = reader.ReadRequired<uint32_t>();
-	for (idx_t i = 0; i < replace_count; i++) {
-		auto name = source.Read<string>();
-		auto expr = ParsedExpression::Deserialize(source);
-		result->replace_list.insert(make_pair(name, std::move(expr)));
-	}
-	result->columns = reader.ReadField<bool>(false);
-	result->expr = reader.ReadOptional<ParsedExpression>(nullptr);
-	return std::move(result);
-}
-
 unique_ptr<ParsedExpression> StarExpression::Copy() const {
 	auto copy = make_uniq<StarExpression>(relation_name);
 	copy->exclude_list = exclude_list;

package/src/duckdb/src/parser/expression/subquery_expression.cpp

@@ -1,9 +1,8 @@
 #include "duckdb/parser/expression/subquery_expression.hpp"
 
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
 
 namespace duckdb {
 
@@ -49,29 +48,4 @@ unique_ptr<ParsedExpression> SubqueryExpression::Copy() const {
 	return std::move(copy);
 }
 
-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);
-	writer.WriteOptional(child);
-	writer.WriteField<ExpressionType>(comparison_type);
-}
-
-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_uniq<SubqueryExpression>();
-	expression->subquery_type = subquery_type;
-	expression->subquery = std::move(subquery);
-	expression->child = reader.ReadOptional<ParsedExpression>(nullptr);
-	expression->comparison_type = reader.ReadRequired<ExpressionType>();
-	return std::move(expression);
-}
-
 } // namespace duckdb