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

package/src/duckdb/src/parser/result_modifier.cpp

@@ -1,8 +1,7 @@
 #include "duckdb/parser/result_modifier.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 {
 
@@ -10,38 +9,6 @@ bool ResultModifier::Equals(const ResultModifier &other) const {
 	return type == other.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) {
-	FieldReader reader(source);
-	auto type = reader.ReadRequired<ResultModifierType>();
-
-	unique_ptr<ResultModifier> result;
-	switch (type) {
-	case ResultModifierType::LIMIT_MODIFIER:
-		result = LimitModifier::Deserialize(reader);
-		break;
-	case ResultModifierType::ORDER_MODIFIER:
-		result = OrderModifier::Deserialize(reader);
-		break;
-	case ResultModifierType::DISTINCT_MODIFIER:
-		result = DistinctModifier::Deserialize(reader);
-		break;
-	case ResultModifierType::LIMIT_PERCENT_MODIFIER:
-		result = LimitPercentModifier::Deserialize(reader);
-		break;
-	default:
-		throw InternalException("Unrecognized ResultModifierType for Deserialization");
-	}
-	reader.Finalize();
-	return result;
-}
-
 bool LimitModifier::Equals(const ResultModifier &other_p) const {
 	if (!ResultModifier::Equals(other_p)) {
 		return false;
@@ -67,18 +34,6 @@ unique_ptr<ResultModifier> LimitModifier::Copy() const {
 	return std::move(copy);
 }
 
-void LimitModifier::Serialize(FieldWriter &writer) const {
-	writer.WriteOptional(limit);
-	writer.WriteOptional(offset);
-}
-
-unique_ptr<ResultModifier> LimitModifier::Deserialize(FieldReader &reader) {
-	auto mod = make_uniq<LimitModifier>();
-	mod->limit = reader.ReadOptional<ParsedExpression>(nullptr);
-	mod->offset = reader.ReadOptional<ParsedExpression>(nullptr);
-	return std::move(mod);
-}
-
 bool DistinctModifier::Equals(const ResultModifier &other_p) const {
 	if (!ResultModifier::Equals(other_p)) {
 		return false;
@@ -98,16 +53,6 @@ unique_ptr<ResultModifier> DistinctModifier::Copy() const {
 	return std::move(copy);
 }
 
-void DistinctModifier::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializableList(distinct_on_targets);
-}
-
-unique_ptr<ResultModifier> DistinctModifier::Deserialize(FieldReader &reader) {
-	auto mod = make_uniq<DistinctModifier>();
-	mod->distinct_on_targets = reader.ReadRequiredSerializableList<ParsedExpression>();
-	return std::move(mod);
-}
-
 bool OrderModifier::Equals(const ResultModifier &other_p) const {
 	if (!ResultModifier::Equals(other_p)) {
 		return false;
@@ -171,33 +116,6 @@ string OrderByNode::ToString() const {
 	return str;
 }
 
-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) {
-	FieldReader reader(source);
-	auto type = reader.ReadRequired<OrderType>();
-	auto null_order = reader.ReadRequired<OrderByNullType>();
-	auto expression = reader.ReadRequiredSerializable<ParsedExpression>();
-	reader.Finalize();
-	return OrderByNode(type, null_order, std::move(expression));
-}
-
-void OrderModifier::Serialize(FieldWriter &writer) const {
-	writer.WriteRegularSerializableList(orders);
-}
-
-unique_ptr<ResultModifier> OrderModifier::Deserialize(FieldReader &reader) {
-	auto mod = make_uniq<OrderModifier>();
-	mod->orders = reader.ReadRequiredSerializableList<OrderByNode, OrderByNode>();
-	return std::move(mod);
-}
-
 bool LimitPercentModifier::Equals(const ResultModifier &other_p) const {
 	if (!ResultModifier::Equals(other_p)) {
 		return false;
@@ -223,16 +141,4 @@ unique_ptr<ResultModifier> LimitPercentModifier::Copy() const {
 	return std::move(copy);
 }
 
-void LimitPercentModifier::Serialize(FieldWriter &writer) const {
-	writer.WriteOptional(limit);
-	writer.WriteOptional(offset);
-}
-
-unique_ptr<ResultModifier> LimitPercentModifier::Deserialize(FieldReader &reader) {
-	auto mod = make_uniq<LimitPercentModifier>();
-	mod->limit = reader.ReadOptional<ParsedExpression>(nullptr);
-	mod->offset = reader.ReadOptional<ParsedExpression>(nullptr);
-	return std::move(mod);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/statement/select_statement.cpp

@@ -1,8 +1,7 @@
 #include "duckdb/parser/statement/select_statement.hpp"
 
-#include "duckdb/common/serializer.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 {
 
@@ -13,16 +12,6 @@ unique_ptr<SQLStatement> SelectStatement::Copy() const {
 	return unique_ptr<SelectStatement>(new SelectStatement(*this));
 }
 
-void SelectStatement::Serialize(Serializer &serializer) const {
-	node->Serialize(serializer);
-}
-
-unique_ptr<SelectStatement> SelectStatement::Deserialize(Deserializer &source) {
-	auto result = make_uniq<SelectStatement>();
-	result->node = QueryNode::Deserialize(source);
-	return result;
-}
-
 bool SelectStatement::Equals(const SQLStatement &other_p) const {
 	if (type != other_p.type) {
 		return false;

package/src/duckdb/src/parser/tableref/basetableref.cpp

@@ -1,9 +1,8 @@
 #include "duckdb/parser/tableref/basetableref.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 {
 
@@ -24,24 +23,6 @@ bool BaseTableRef::Equals(const TableRef &other_p) const {
 	       column_name_alias == other.column_name_alias;
 }
 
-void BaseTableRef::Serialize(FieldWriter &writer) const {
-	writer.WriteString(schema_name);
-	writer.WriteString(table_name);
-	writer.WriteList<string>(column_name_alias);
-	writer.WriteString(catalog_name);
-}
-
-unique_ptr<TableRef> BaseTableRef::Deserialize(FieldReader &reader) {
-	auto result = make_uniq<BaseTableRef>();
-
-	result->schema_name = reader.ReadRequired<string>();
-	result->table_name = reader.ReadRequired<string>();
-	result->column_name_alias = reader.ReadRequiredList<string>();
-	result->catalog_name = reader.ReadField<string>(INVALID_CATALOG);
-
-	return std::move(result);
-}
-
 unique_ptr<TableRef> BaseTableRef::Copy() {
 	auto copy = make_uniq<BaseTableRef>();
 

package/src/duckdb/src/parser/tableref/emptytableref.cpp

@@ -1,7 +1,5 @@
 #include "duckdb/parser/tableref/emptytableref.hpp"
 
-#include "duckdb/common/field_writer.hpp"
-
 namespace duckdb {
 
 string EmptyTableRef::ToString() const {
@@ -16,11 +14,4 @@ unique_ptr<TableRef> EmptyTableRef::Copy() {
 	return make_uniq<EmptyTableRef>();
 }
 
-void EmptyTableRef::Serialize(FieldWriter &writer) const {
-}
-
-unique_ptr<TableRef> EmptyTableRef::Deserialize(FieldReader &reader) {
-	return make_uniq<EmptyTableRef>();
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/tableref/expressionlistref.cpp

@@ -1,8 +1,7 @@
 #include "duckdb/parser/tableref/expressionlistref.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 {
 
@@ -65,29 +64,4 @@ unique_ptr<TableRef> ExpressionListRef::Copy() {
 	return std::move(result);
 }
 
-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(FieldReader &reader) {
-	auto result = make_uniq<ExpressionListRef>();
-	// value list
-	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);
-		result->values.push_back(std::move(value_list));
-	}
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/tableref/joinref.cpp

@@ -1,9 +1,8 @@
 #include "duckdb/parser/tableref/joinref.hpp"
 
 #include "duckdb/common/limits.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 {
 
@@ -82,24 +81,4 @@ unique_ptr<TableRef> JoinRef::Copy() {
 	return std::move(copy);
 }
 
-void JoinRef::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*left);
-	writer.WriteSerializable(*right);
-	writer.WriteOptional(condition);
-	writer.WriteField<JoinType>(type);
-	writer.WriteField<JoinRefType>(ref_type);
-	writer.WriteList<string>(using_columns);
-}
-
-unique_ptr<TableRef> JoinRef::Deserialize(FieldReader &reader) {
-	auto result = make_uniq<JoinRef>(JoinRefType::REGULAR);
-	result->left = reader.ReadRequiredSerializable<TableRef>();
-	result->right = reader.ReadRequiredSerializable<TableRef>();
-	result->condition = reader.ReadOptional<ParsedExpression>(nullptr);
-	result->type = reader.ReadRequired<JoinType>();
-	result->ref_type = reader.ReadRequired<JoinRefType>();
-	result->using_columns = reader.ReadRequiredList<string>();
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/tableref/pivotref.cpp

@@ -1,7 +1,6 @@
 #include "duckdb/parser/tableref/pivotref.hpp"
 
 #include "duckdb/common/limits.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
@@ -119,26 +118,6 @@ PivotColumn PivotColumn::Copy() const {
 	return result;
 }
 
-void PivotColumn::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteSerializableList(pivot_expressions);
-	writer.WriteList<string>(unpivot_names);
-	writer.WriteRegularSerializableList(entries);
-	writer.WriteString(pivot_enum);
-	writer.Finalize();
-}
-
-PivotColumn PivotColumn::Deserialize(Deserializer &source) {
-	PivotColumn result;
-	FieldReader reader(source);
-	result.pivot_expressions = reader.ReadRequiredSerializableList<ParsedExpression>();
-	result.unpivot_names = reader.ReadRequiredList<string>();
-	result.entries = reader.ReadRequiredSerializableList<PivotColumnEntry, PivotColumnEntry>();
-	result.pivot_enum = reader.ReadRequired<string>();
-	reader.Finalize();
-	return result;
-}
-
 //===--------------------------------------------------------------------===//
 // PivotColumnEntry
 //===--------------------------------------------------------------------===//
@@ -150,24 +129,6 @@ PivotColumnEntry PivotColumnEntry::Copy() const {
 	return result;
 }
 
-void PivotColumnEntry::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteRegularSerializableList(values);
-	writer.WriteOptional(star_expr);
-	writer.WriteString(alias);
-	writer.Finalize();
-}
-
-PivotColumnEntry PivotColumnEntry::Deserialize(Deserializer &source) {
-	PivotColumnEntry result;
-	FieldReader reader(source);
-	result.values = reader.ReadRequiredSerializableList<Value, Value>();
-	result.star_expr = reader.ReadOptional<ParsedExpression>(nullptr);
-	result.alias = reader.ReadRequired<string>();
-	reader.Finalize();
-	return result;
-}
-
 //===--------------------------------------------------------------------===//
 // PivotRef
 //===--------------------------------------------------------------------===//
@@ -288,26 +249,4 @@ unique_ptr<TableRef> PivotRef::Copy() {
 	return std::move(copy);
 }
 
-void PivotRef::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*source);
-	writer.WriteSerializableList(aggregates);
-	writer.WriteList<string>(unpivot_names);
-	writer.WriteRegularSerializableList(pivots);
-	writer.WriteList<string>(groups);
-	writer.WriteList<string>(column_name_alias);
-	writer.WriteField<bool>(include_nulls);
-}
-
-unique_ptr<TableRef> PivotRef::Deserialize(FieldReader &reader) {
-	auto result = make_uniq<PivotRef>();
-	result->source = reader.ReadRequiredSerializable<TableRef>();
-	result->aggregates = reader.ReadRequiredSerializableList<ParsedExpression>();
-	result->unpivot_names = reader.ReadRequiredList<string>();
-	result->pivots = reader.ReadRequiredSerializableList<PivotColumn, PivotColumn>();
-	result->groups = reader.ReadRequiredList<string>();
-	result->column_name_alias = reader.ReadRequiredList<string>();
-	result->include_nulls = reader.ReadRequired<bool>();
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/tableref/subqueryref.cpp

@@ -1,9 +1,8 @@
 #include "duckdb/parser/tableref/subqueryref.hpp"
 
 #include "duckdb/common/limits.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 {
 
@@ -35,16 +34,4 @@ unique_ptr<TableRef> SubqueryRef::Copy() {
 	return std::move(copy);
 }
 
-void SubqueryRef::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*subquery);
-	writer.WriteList<string>(column_name_alias);
-}
-
-unique_ptr<TableRef> SubqueryRef::Deserialize(FieldReader &reader) {
-	auto subquery = reader.ReadRequiredSerializable<SelectStatement>();
-	auto result = make_uniq<SubqueryRef>(std::move(subquery));
-	result->column_name_alias = reader.ReadRequiredList<string>();
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/tableref/table_function.cpp

@@ -1,8 +1,7 @@
 #include "duckdb/parser/tableref/table_function_ref.hpp"
 #include "duckdb/common/vector.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 {
 
@@ -21,20 +20,6 @@ bool TableFunctionRef::Equals(const TableRef &other_p) const {
 	return function->Equals(*other.function);
 }
 
-void TableFunctionRef::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*function);
-	writer.WriteString(alias);
-	writer.WriteList<string>(column_name_alias);
-}
-
-unique_ptr<TableRef> TableFunctionRef::Deserialize(FieldReader &reader) {
-	auto result = make_uniq<TableFunctionRef>();
-	result->function = reader.ReadRequiredSerializable<ParsedExpression>();
-	result->alias = reader.ReadRequired<string>();
-	result->column_name_alias = reader.ReadRequiredList<string>();
-	return std::move(result);
-}
-
 unique_ptr<TableRef> TableFunctionRef::Copy() {
 	auto copy = make_uniq<TableFunctionRef>();
 

package/src/duckdb/src/parser/tableref.cpp

@@ -1,10 +1,9 @@
 #include "duckdb/parser/tableref.hpp"
 
 #include "duckdb/common/printer.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/tableref/list.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/common/to_string.hpp"
 
 namespace duckdb {
@@ -44,55 +43,6 @@ bool TableRef::Equals(const TableRef &other) const {
 	return type == other.type && alias == other.alias && SampleOptions::Equals(sample.get(), other.sample.get());
 }
 
-void TableRef::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField<TableReferenceType>(type);
-	writer.WriteString(alias);
-	writer.WriteOptional(sample);
-	Serialize(writer);
-	writer.Finalize();
-}
-
-unique_ptr<TableRef> TableRef::Deserialize(Deserializer &source) {
-	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(reader);
-		break;
-	case TableReferenceType::JOIN:
-		result = JoinRef::Deserialize(reader);
-		break;
-	case TableReferenceType::SUBQUERY:
-		result = SubqueryRef::Deserialize(reader);
-		break;
-	case TableReferenceType::TABLE_FUNCTION:
-		result = TableFunctionRef::Deserialize(reader);
-		break;
-	case TableReferenceType::EMPTY:
-		result = EmptyTableRef::Deserialize(reader);
-		break;
-	case TableReferenceType::EXPRESSION_LIST:
-		result = ExpressionListRef::Deserialize(reader);
-		break;
-	case TableReferenceType::PIVOT:
-		result = PivotRef::Deserialize(reader);
-		break;
-	case TableReferenceType::CTE:
-	case TableReferenceType::INVALID:
-		throw InternalException("Unsupported type for TableRef::Deserialize");
-	}
-	reader.Finalize();
-
-	result->alias = alias;
-	result->sample = std::move(sample);
-	return result;
-}
-
 void TableRef::CopyProperties(TableRef &target) const {
 	D_ASSERT(type == target.type);
 	target.alias = alias;

package/src/duckdb/src/planner/binder/expression/bind_subquery_expression.cpp

@@ -32,11 +32,8 @@ public:
 	unique_ptr<QueryNode> Copy() const override {
 		throw InternalException("Cannot copy bound subquery node");
 	}
-	void Serialize(FieldWriter &writer) const override {
-		throw InternalException("Cannot serialize bound subquery node");
-	}
 
-	void FormatSerialize(FormatSerializer &serializer) const override {
+	void Serialize(Serializer &serializer) const override {
 		throw InternalException("Cannot serialize bound subquery node");
 	}
 };

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