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

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

@@ -1,5 +1,4 @@
 #include "duckdb/planner/bound_result_modifier.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
@@ -16,20 +15,6 @@ BoundOrderByNode::BoundOrderByNode(OrderType type, OrderByNullType null_order, u
                                    unique_ptr<BaseStatistics> stats)
     : type(type), null_order(null_order), expression(std::move(expression)), stats(std::move(stats)) {
 }
-void BoundOrderModifier::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteRegularSerializableList(orders);
-	writer.Finalize();
-}
-unique_ptr<BoundOrderModifier> BoundOrderModifier::Deserialize(Deserializer &source, PlanDeserializationState &state) {
-	auto x = make_uniq<BoundOrderModifier>();
-
-	FieldReader reader(source);
-	x->orders = reader.ReadRequiredSerializableList<BoundOrderByNode, BoundOrderByNode>(state);
-	reader.Finalize();
-
-	return x;
-}
 
 BoundOrderByNode BoundOrderByNode::Copy() const {
 	if (stats) {
@@ -76,24 +61,6 @@ string BoundOrderByNode::ToString() const {
 	return str;
 }
 
-void BoundOrderByNode::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField(type);
-	writer.WriteField(null_order);
-	writer.WriteSerializable(*expression);
-	// TODO statistics
-	writer.Finalize();
-}
-
-BoundOrderByNode BoundOrderByNode::Deserialize(Deserializer &source, PlanDeserializationState &state) {
-	FieldReader reader(source);
-	auto type = reader.ReadRequired<OrderType>();
-	auto null_order = reader.ReadRequired<OrderByNullType>();
-	auto expression = reader.ReadRequiredSerializable<Expression>(state);
-	reader.Finalize();
-	return BoundOrderByNode(type, null_order, std::move(expression));
-}
-
 unique_ptr<BoundOrderModifier> BoundOrderModifier::Copy() const {
 	auto result = make_uniq<BoundOrderModifier>();
 	for (auto &order : orders) {

package/src/duckdb/src/planner/expression/bound_aggregate_expression.cpp

@@ -3,7 +3,6 @@
 
 #include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
 #include "duckdb/common/types/hash.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/planner/expression/bound_cast_expression.hpp"
 #include "duckdb/function/function_serialization.hpp"
 
@@ -81,44 +80,21 @@ unique_ptr<Expression> BoundAggregateExpression::Copy() {
 	return std::move(copy);
 }
 
-void BoundAggregateExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteField(IsDistinct());
-	writer.WriteOptional(filter);
-	writer.WriteOptional(order_bys);
-	FunctionSerializer::Serialize<AggregateFunction>(writer, function, return_type, children, bind_info.get());
-}
-
-unique_ptr<Expression> BoundAggregateExpression::Deserialize(ExpressionDeserializationState &state,
-                                                             FieldReader &reader) {
-	auto distinct = reader.ReadRequired<bool>();
-	auto filter = reader.ReadOptional<Expression>(nullptr, state.gstate);
-	auto order_bys = reader.ReadOptional<BoundOrderModifier>(nullptr, state.gstate);
-	vector<unique_ptr<Expression>> children;
-	unique_ptr<FunctionData> bind_info;
-	auto function = FunctionSerializer::Deserialize<AggregateFunction, AggregateFunctionCatalogEntry>(
-	    reader, state, CatalogType::AGGREGATE_FUNCTION_ENTRY, children, bind_info);
-
-	auto x = make_uniq<BoundAggregateExpression>(function, std::move(children), std::move(filter), std::move(bind_info),
-	                                             distinct ? AggregateType::DISTINCT : AggregateType::NON_DISTINCT);
-	x->order_bys = std::move(order_bys);
-	return std::move(x);
-}
-
-void BoundAggregateExpression::FormatSerialize(FormatSerializer &serializer) const {
-	Expression::FormatSerialize(serializer);
+void BoundAggregateExpression::Serialize(Serializer &serializer) const {
+	Expression::Serialize(serializer);
 	serializer.WriteProperty(200, "return_type", return_type);
 	serializer.WriteProperty(201, "children", children);
-	FunctionSerializer::FormatSerialize(serializer, function, bind_info.get());
+	FunctionSerializer::Serialize(serializer, function, bind_info.get());
 	serializer.WriteProperty(203, "aggregate_type", aggr_type);
 	serializer.WritePropertyWithDefault(204, "filter", filter, unique_ptr<Expression>());
 	serializer.WritePropertyWithDefault(205, "order_bys", order_bys, unique_ptr<BoundOrderModifier>());
 }
 
-unique_ptr<Expression> BoundAggregateExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<Expression> BoundAggregateExpression::Deserialize(Deserializer &deserializer) {
 	auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
 	auto children = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(201, "children");
-	auto entry = FunctionSerializer::FormatDeserialize<AggregateFunction, AggregateFunctionCatalogEntry>(
-	    deserializer, CatalogType::AGGREGATE_FUNCTION_ENTRY, children);
+	auto entry = FunctionSerializer::Deserialize<AggregateFunction, AggregateFunctionCatalogEntry>(
+	    deserializer, CatalogType::AGGREGATE_FUNCTION_ENTRY, children, std::move(return_type));
 	auto aggregate_type = deserializer.ReadProperty<AggregateType>(203, "aggregate_type");
 	auto filter = deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(204, "filter", unique_ptr<Expression>());
 	auto result = make_uniq<BoundAggregateExpression>(std::move(entry.first), std::move(children), std::move(filter),

package/src/duckdb/src/planner/expression/bound_between_expression.cpp

@@ -1,6 +1,5 @@
 #include "duckdb/planner/expression/bound_between_expression.hpp"
 #include "duckdb/parser/expression/between_expression.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
@@ -43,22 +42,4 @@ unique_ptr<Expression> BoundBetweenExpression::Copy() {
 	return std::move(copy);
 }
 
-void BoundBetweenExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteOptional(input);
-	writer.WriteOptional(lower);
-	writer.WriteOptional(upper);
-	writer.WriteField(lower_inclusive);
-	writer.WriteField(upper_inclusive);
-}
-
-unique_ptr<Expression> BoundBetweenExpression::Deserialize(ExpressionDeserializationState &state, FieldReader &reader) {
-	auto input = reader.ReadOptional<Expression>(nullptr, state.gstate);
-	auto lower = reader.ReadOptional<Expression>(nullptr, state.gstate);
-	auto upper = reader.ReadOptional<Expression>(nullptr, state.gstate);
-	auto lower_inclusive = reader.ReadRequired<bool>();
-	auto upper_inclusive = reader.ReadRequired<bool>();
-	return make_uniq<BoundBetweenExpression>(std::move(input), std::move(lower), std::move(upper), lower_inclusive,
-	                                         upper_inclusive);
-}
-
 } // namespace duckdb

package/src/duckdb/src/planner/expression/bound_case_expression.cpp

@@ -1,6 +1,5 @@
 #include "duckdb/planner/expression/bound_case_expression.hpp"
 #include "duckdb/parser/expression/case_expression.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
@@ -58,39 +57,4 @@ unique_ptr<Expression> BoundCaseExpression::Copy() {
 	return std::move(new_case);
 }
 
-void BoundCaseCheck::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteSerializable(*when_expr);
-	writer.WriteSerializable(*then_expr);
-	writer.Finalize();
-}
-
-BoundCaseCheck BoundCaseCheck::Deserialize(Deserializer &source, PlanDeserializationState &state) {
-	FieldReader reader(source);
-	auto when_expr = reader.ReadRequiredSerializable<Expression>(state);
-	auto then_expr = reader.ReadRequiredSerializable<Expression>(state);
-	reader.Finalize();
-	BoundCaseCheck result;
-	result.when_expr = std::move(when_expr);
-	result.then_expr = std::move(then_expr);
-	return result;
-}
-
-void BoundCaseExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(return_type);
-	writer.WriteRegularSerializableList(case_checks);
-	writer.WriteSerializable(*else_expr);
-}
-
-unique_ptr<Expression> BoundCaseExpression::Deserialize(ExpressionDeserializationState &state, FieldReader &reader) {
-	auto return_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	auto case_checks = reader.ReadRequiredSerializableList<BoundCaseCheck, BoundCaseCheck>(state.gstate);
-	auto else_expr = reader.ReadRequiredSerializable<Expression>(state.gstate);
-
-	auto result = make_uniq<BoundCaseExpression>(return_type);
-	result->else_expr = std::move(else_expr);
-	result->case_checks = std::move(case_checks);
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/planner/expression/bound_cast_expression.cpp

@@ -1,4 +1,3 @@
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/planner/expression/bound_cast_expression.hpp"
 #include "duckdb/planner/expression/bound_default_expression.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
@@ -194,18 +193,4 @@ unique_ptr<Expression> BoundCastExpression::Copy() {
 	return std::move(copy);
 }
 
-void BoundCastExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*child);
-	writer.WriteSerializable(return_type);
-	writer.WriteField(try_cast);
-}
-
-unique_ptr<Expression> BoundCastExpression::Deserialize(ExpressionDeserializationState &state, FieldReader &reader) {
-	auto child = reader.ReadRequiredSerializable<Expression>(state.gstate);
-	auto target_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	auto try_cast = reader.ReadRequired<bool>();
-	auto cast_function = BindCastFunction(state.gstate.context, child->return_type, target_type);
-	return make_uniq<BoundCastExpression>(std::move(child), std::move(target_type), std::move(cast_function), try_cast);
-}
-
 } // namespace duckdb

package/src/duckdb/src/planner/expression/bound_columnref_expression.cpp

@@ -1,6 +1,5 @@
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/main/config.hpp"
 
@@ -56,23 +55,4 @@ string BoundColumnRefExpression::ToString() const {
 	return binding.ToString();
 }
 
-void BoundColumnRefExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteString(alias);
-	writer.WriteSerializable(return_type);
-	writer.WriteField(binding.table_index);
-	writer.WriteField(binding.column_index);
-	writer.WriteField(depth);
-}
-
-unique_ptr<Expression> BoundColumnRefExpression::Deserialize(ExpressionDeserializationState &state,
-                                                             FieldReader &reader) {
-	auto alias = reader.ReadRequired<string>();
-	auto return_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	auto table_index = reader.ReadRequired<idx_t>();
-	auto column_index = reader.ReadRequired<idx_t>();
-	auto depth = reader.ReadRequired<idx_t>();
-
-	return make_uniq<BoundColumnRefExpression>(alias, return_type, ColumnBinding(table_index, column_index), depth);
-}
-
 } // namespace duckdb

package/src/duckdb/src/planner/expression/bound_comparison_expression.cpp

@@ -1,4 +1,3 @@
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/planner/expression/bound_comparison_expression.hpp"
 #include "duckdb/parser/expression/comparison_expression.hpp"
 
@@ -34,16 +33,4 @@ unique_ptr<Expression> BoundComparisonExpression::Copy() {
 	return std::move(copy);
 }
 
-void BoundComparisonExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteOptional(left);
-	writer.WriteOptional(right);
-}
-
-unique_ptr<Expression> BoundComparisonExpression::Deserialize(ExpressionDeserializationState &state,
-                                                              FieldReader &reader) {
-	auto left = reader.ReadOptional<Expression>(nullptr, state.gstate);
-	auto right = reader.ReadOptional<Expression>(nullptr, state.gstate);
-	return make_uniq<BoundComparisonExpression>(state.type, std::move(left), std::move(right));
-}
-
 } // namespace duckdb

package/src/duckdb/src/planner/expression/bound_conjunction_expression.cpp

@@ -1,7 +1,6 @@
 #include "duckdb/planner/expression/bound_conjunction_expression.hpp"
 #include "duckdb/parser/expression/conjunction_expression.hpp"
 #include "duckdb/parser/expression_util.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
@@ -41,16 +40,4 @@ unique_ptr<Expression> BoundConjunctionExpression::Copy() {
 	return std::move(copy);
 }
 
-void BoundConjunctionExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializableList(children);
-}
-
-unique_ptr<Expression> BoundConjunctionExpression::Deserialize(ExpressionDeserializationState &state,
-                                                               FieldReader &reader) {
-	auto children = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-	auto res = make_uniq<BoundConjunctionExpression>(state.type);
-	res->children = std::move(children);
-	return std::move(res);
-}
-
 } // namespace duckdb

package/src/duckdb/src/planner/expression/bound_constant_expression.cpp

@@ -1,5 +1,4 @@
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/common/value_operations/value_operations.hpp"
 
@@ -33,14 +32,4 @@ unique_ptr<Expression> BoundConstantExpression::Copy() {
 	return std::move(copy);
 }
 
-void BoundConstantExpression::Serialize(FieldWriter &writer) const {
-	value.Serialize(writer.GetSerializer());
-}
-
-unique_ptr<Expression> BoundConstantExpression::Deserialize(ExpressionDeserializationState &state,
-                                                            FieldReader &reader) {
-	auto value = Value::Deserialize(reader.GetSource());
-	return make_uniq<BoundConstantExpression>(value);
-}
-
 } // namespace duckdb

package/src/duckdb/src/planner/expression/bound_expression.cpp

@@ -33,11 +33,7 @@ unique_ptr<ParsedExpression> BoundExpression::Copy() const {
 	throw SerializationException("Cannot copy or serialize bound expression");
 }
 
-void BoundExpression::Serialize(FieldWriter &writer) const {
-	throw SerializationException("Cannot copy or serialize bound expression");
-}
-
-void BoundExpression::FormatSerialize(FormatSerializer &serializer) const {
+void BoundExpression::Serialize(Serializer &serializer) const {
 	throw SerializationException("Cannot copy or serialize bound expression");
 }
 

package/src/duckdb/src/planner/expression/bound_function_expression.cpp

@@ -3,8 +3,8 @@
 #include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/function/function_serialization.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 {
 
@@ -75,39 +75,19 @@ void BoundFunctionExpression::Verify() const {
 	D_ASSERT(!function.name.empty());
 }
 
-void BoundFunctionExpression::Serialize(FieldWriter &writer) const {
-	D_ASSERT(!function.name.empty());
-	D_ASSERT(return_type == function.return_type);
-	writer.WriteField(is_operator);
-	FunctionSerializer::Serialize<ScalarFunction>(writer, function, return_type, children, bind_info.get());
-}
-
-unique_ptr<Expression> BoundFunctionExpression::Deserialize(ExpressionDeserializationState &state,
-                                                            FieldReader &reader) {
-	auto is_operator = reader.ReadRequired<bool>();
-	vector<unique_ptr<Expression>> children;
-	unique_ptr<FunctionData> bind_info;
-	auto function = FunctionSerializer::Deserialize<ScalarFunction, ScalarFunctionCatalogEntry>(
-	    reader, state, CatalogType::SCALAR_FUNCTION_ENTRY, children, bind_info);
-
-	auto return_type = function.return_type;
-	return make_uniq<BoundFunctionExpression>(std::move(return_type), std::move(function), std::move(children),
-	                                          std::move(bind_info), is_operator);
-}
-
-void BoundFunctionExpression::FormatSerialize(FormatSerializer &serializer) const {
-	Expression::FormatSerialize(serializer);
+void BoundFunctionExpression::Serialize(Serializer &serializer) const {
+	Expression::Serialize(serializer);
 	serializer.WriteProperty(200, "return_type", return_type);
 	serializer.WriteProperty(201, "children", children);
-	FunctionSerializer::FormatSerialize(serializer, function, bind_info.get());
+	FunctionSerializer::Serialize(serializer, function, bind_info.get());
 	serializer.WriteProperty(202, "is_operator", is_operator);
 }
 
-unique_ptr<Expression> BoundFunctionExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<Expression> BoundFunctionExpression::Deserialize(Deserializer &deserializer) {
 	auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
 	auto children = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(201, "children");
-	auto entry = FunctionSerializer::FormatDeserialize<ScalarFunction, ScalarFunctionCatalogEntry>(
-	    deserializer, CatalogType::SCALAR_FUNCTION_ENTRY, children);
+	auto entry = FunctionSerializer::Deserialize<ScalarFunction, ScalarFunctionCatalogEntry>(
+	    deserializer, CatalogType::SCALAR_FUNCTION_ENTRY, children, return_type);
 	auto result = make_uniq<BoundFunctionExpression>(std::move(return_type), std::move(entry.first),
 	                                                 std::move(children), std::move(entry.second));
 	deserializer.ReadProperty(202, "is_operator", result->is_operator);

package/src/duckdb/src/planner/expression/bound_lambda_expression.cpp

@@ -38,8 +38,4 @@ unique_ptr<Expression> BoundLambdaExpression::Copy() {
 	return std::move(copy);
 }
 
-void BoundLambdaExpression::Serialize(FieldWriter &writer) const {
-	throw NotImplementedException(ExpressionTypeToString(type));
-}
-
 } // namespace duckdb

package/src/duckdb/src/planner/expression/bound_lambdaref_expression.cpp

@@ -2,7 +2,6 @@
 
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/common/to_string.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
@@ -46,26 +45,4 @@ string BoundLambdaRefExpression::ToString() const {
 	       to_string(lambda_index) + "]";
 }
 
-void BoundLambdaRefExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteString(alias);
-	writer.WriteSerializable(return_type);
-	writer.WriteField(lambda_index);
-	writer.WriteField(binding.table_index);
-	writer.WriteField(binding.column_index);
-	writer.WriteField(depth);
-}
-
-unique_ptr<Expression> BoundLambdaRefExpression::Deserialize(ExpressionDeserializationState &state,
-                                                             FieldReader &reader) {
-	auto alias = reader.ReadRequired<string>();
-	auto return_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	auto lambda_index = reader.ReadRequired<idx_t>();
-	auto table_index = reader.ReadRequired<idx_t>();
-	auto column_index = reader.ReadRequired<idx_t>();
-	auto depth = reader.ReadRequired<idx_t>();
-
-	return make_uniq<BoundLambdaRefExpression>(alias, return_type, ColumnBinding(table_index, column_index),
-	                                           lambda_index, depth);
-}
-
 } // namespace duckdb

package/src/duckdb/src/planner/expression/bound_operator_expression.cpp

@@ -1,7 +1,6 @@
 #include "duckdb/planner/expression/bound_operator_expression.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/parser/expression/operator_expression.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
@@ -33,19 +32,4 @@ unique_ptr<Expression> BoundOperatorExpression::Copy() {
 	return std::move(copy);
 }
 
-void BoundOperatorExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(return_type);
-	writer.WriteSerializableList(children);
-}
-
-unique_ptr<Expression> BoundOperatorExpression::Deserialize(ExpressionDeserializationState &state,
-                                                            FieldReader &reader) {
-	auto return_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	auto children = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-
-	auto result = make_uniq<BoundOperatorExpression>(state.type, return_type);
-	result->children = std::move(children);
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/planner/expression/bound_parameter_expression.cpp

@@ -2,7 +2,6 @@
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/common/to_string.hpp"
 #include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
@@ -82,21 +81,4 @@ unique_ptr<Expression> BoundParameterExpression::Copy() {
 	return std::move(result);
 }
 
-void BoundParameterExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteString(identifier);
-	writer.WriteSerializable(return_type);
-	writer.WriteSerializable(*parameter_data);
-}
-
-unique_ptr<Expression> BoundParameterExpression::Deserialize(ExpressionDeserializationState &state,
-                                                             FieldReader &reader) {
-	auto &global_parameter_set = state.gstate.parameter_data;
-	auto identifier = reader.ReadRequired<string>();
-	auto return_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	auto parameter_data = reader.ReadRequiredSerializable<BoundParameterData, shared_ptr<BoundParameterData>>();
-	auto result = unique_ptr<BoundParameterExpression>(new BoundParameterExpression(
-	    global_parameter_set, std::move(identifier), std::move(return_type), std::move(parameter_data)));
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/planner/expression/bound_reference_expression.cpp

@@ -1,7 +1,5 @@
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
 
-#include "duckdb/common/field_writer.hpp"
-#include "duckdb/common/serializer.hpp"
 #include "duckdb/common/to_string.hpp"
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/main/config.hpp"
@@ -44,18 +42,4 @@ unique_ptr<Expression> BoundReferenceExpression::Copy() {
 	return make_uniq<BoundReferenceExpression>(alias, return_type, index);
 }
 
-void BoundReferenceExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteString(alias);
-	writer.WriteSerializable(return_type);
-	writer.WriteField(index);
-}
-
-unique_ptr<Expression> BoundReferenceExpression::Deserialize(ExpressionDeserializationState &state,
-                                                             FieldReader &reader) {
-	auto alias = reader.ReadRequired<string>();
-	auto return_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	auto index = reader.ReadRequired<idx_t>();
-	return make_uniq<BoundReferenceExpression>(alias, return_type, index);
-}
-
 } // namespace duckdb

package/src/duckdb/src/planner/expression/bound_subquery_expression.cpp

@@ -26,8 +26,4 @@ bool BoundSubqueryExpression::PropagatesNullValues() const {
 	return false;
 }
 
-void BoundSubqueryExpression::Serialize(FieldWriter &writer) const {
-	throw NotImplementedException(ExpressionTypeToString(type));
-}
-
 } // namespace duckdb

package/src/duckdb/src/planner/expression/bound_unnest_expression.cpp

@@ -2,7 +2,6 @@
 
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/common/string_util.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
@@ -40,18 +39,4 @@ unique_ptr<Expression> BoundUnnestExpression::Copy() {
 	return std::move(copy);
 }
 
-void BoundUnnestExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(return_type);
-	writer.WriteSerializable(*child);
-}
-
-unique_ptr<Expression> BoundUnnestExpression::Deserialize(ExpressionDeserializationState &state, FieldReader &reader) {
-	auto return_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	auto child = reader.ReadRequiredSerializable<Expression>(state.gstate);
-
-	auto result = make_uniq<BoundUnnestExpression>(return_type);
-	result->child = std::move(child);
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/planner/expression/bound_window_expression.cpp

@@ -108,67 +108,13 @@ unique_ptr<Expression> BoundWindowExpression::Copy() {
 	return std::move(new_window);
 }
 
-void BoundWindowExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteField<bool>(aggregate.get());
-	if (aggregate) {
-		D_ASSERT(return_type == aggregate->return_type);
-		FunctionSerializer::Serialize<AggregateFunction>(writer, *aggregate, return_type, children, bind_info.get());
-	} else {
-		// children and return_type are written as part of the aggregate function otherwise
-		writer.WriteSerializableList(children);
-		writer.WriteSerializable(return_type);
-	}
-	writer.WriteSerializableList(partitions);
-	writer.WriteRegularSerializableList(orders);
-	// FIXME: partitions_stats
-	writer.WriteOptional(filter_expr);
-	writer.WriteField<bool>(ignore_nulls);
-	writer.WriteField<WindowBoundary>(start);
-	writer.WriteField<WindowBoundary>(end);
-	writer.WriteOptional(start_expr);
-	writer.WriteOptional(end_expr);
-	writer.WriteOptional(offset_expr);
-	writer.WriteOptional(default_expr);
-}
-
-unique_ptr<Expression> BoundWindowExpression::Deserialize(ExpressionDeserializationState &state, FieldReader &reader) {
-	auto has_aggregate = reader.ReadRequired<bool>();
-	unique_ptr<AggregateFunction> aggregate;
-	unique_ptr<FunctionData> bind_info;
-	vector<unique_ptr<Expression>> children;
-	LogicalType return_type;
-	if (has_aggregate) {
-		auto aggr_function = FunctionSerializer::Deserialize<AggregateFunction, AggregateFunctionCatalogEntry>(
-		    reader, state, CatalogType::AGGREGATE_FUNCTION_ENTRY, children, bind_info);
-		aggregate = make_uniq<AggregateFunction>(std::move(aggr_function));
-		return_type = aggregate->return_type;
-	} else {
-		children = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-		return_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	}
-	auto result = make_uniq<BoundWindowExpression>(state.type, return_type, std::move(aggregate), std::move(bind_info));
-
-	result->partitions = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-	result->orders = reader.ReadRequiredSerializableList<BoundOrderByNode, BoundOrderByNode>(state.gstate);
-	result->filter_expr = reader.ReadOptional<Expression>(nullptr, state.gstate);
-	result->ignore_nulls = reader.ReadRequired<bool>();
-	result->start = reader.ReadRequired<WindowBoundary>();
-	result->end = reader.ReadRequired<WindowBoundary>();
-	result->start_expr = reader.ReadOptional<Expression>(nullptr, state.gstate);
-	result->end_expr = reader.ReadOptional<Expression>(nullptr, state.gstate);
-	result->offset_expr = reader.ReadOptional<Expression>(nullptr, state.gstate);
-	result->default_expr = reader.ReadOptional<Expression>(nullptr, state.gstate);
-	result->children = std::move(children);
-	return std::move(result);
-}
-
-void BoundWindowExpression::FormatSerialize(FormatSerializer &serializer) const {
-	Expression::FormatSerialize(serializer);
+void BoundWindowExpression::Serialize(Serializer &serializer) const {
+	Expression::Serialize(serializer);
 	serializer.WriteProperty(200, "return_type", return_type);
 	serializer.WriteProperty(201, "children", children);
 	if (type == ExpressionType::WINDOW_AGGREGATE) {
 		D_ASSERT(aggregate);
-		FunctionSerializer::FormatSerialize(serializer, *aggregate, bind_info.get());
+		FunctionSerializer::Serialize(serializer, *aggregate, bind_info.get());
 	}
 	serializer.WriteProperty(202, "partitions", partitions);
 	serializer.WriteProperty(203, "orders", orders);
@@ -182,20 +128,21 @@ void BoundWindowExpression::FormatSerialize(FormatSerializer &serializer) const
 	serializer.WritePropertyWithDefault(211, "default_expr", default_expr, unique_ptr<Expression>());
 }
 
-unique_ptr<Expression> BoundWindowExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<Expression> BoundWindowExpression::Deserialize(Deserializer &deserializer) {
 	auto expression_type = deserializer.Get<ExpressionType>();
 	auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
 	auto children = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(201, "children");
 	unique_ptr<AggregateFunction> aggregate;
 	unique_ptr<FunctionData> bind_info;
 	if (expression_type == ExpressionType::WINDOW_AGGREGATE) {
-		auto entry = FunctionSerializer::FormatDeserialize<AggregateFunction, AggregateFunctionCatalogEntry>(
-		    deserializer, CatalogType::AGGREGATE_FUNCTION_ENTRY, children);
+		auto entry = FunctionSerializer::Deserialize<AggregateFunction, AggregateFunctionCatalogEntry>(
+		    deserializer, CatalogType::AGGREGATE_FUNCTION_ENTRY, children, return_type);
 		aggregate = make_uniq<AggregateFunction>(std::move(entry.first));
 		bind_info = std::move(entry.second);
 	}
 	auto result =
 	    make_uniq<BoundWindowExpression>(expression_type, return_type, std::move(aggregate), std::move(bind_info));
+	result->children = std::move(children);
 	deserializer.ReadProperty(202, "partitions", result->partitions);
 	deserializer.ReadProperty(203, "orders", result->orders);
 	deserializer.ReadPropertyWithDefault(204, "filters", result->filter_expr, unique_ptr<Expression>());