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

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>());

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

@@ -1,7 +1,6 @@
 #include "duckdb/planner/expression.hpp"
 
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/storage/statistics/base_statistics.hpp"
@@ -96,79 +95,6 @@ hash_t Expression::Hash() const {
 	return hash;
 }
 
-void Expression::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField<ExpressionClass>(expression_class);
-	writer.WriteField<ExpressionType>(type);
-	writer.WriteString(alias);
-	Serialize(writer);
-	writer.Finalize();
-}
-
-unique_ptr<Expression> Expression::Deserialize(Deserializer &source, PlanDeserializationState &gstate) {
-	FieldReader reader(source);
-	auto expression_class = reader.ReadRequired<ExpressionClass>();
-	auto type = reader.ReadRequired<ExpressionType>();
-	auto alias = reader.ReadRequired<string>();
-
-	ExpressionDeserializationState state(gstate, type);
-
-	unique_ptr<Expression> result;
-	switch (expression_class) {
-	case ExpressionClass::BOUND_REF:
-		result = BoundReferenceExpression::Deserialize(state, reader);
-		break;
-	case ExpressionClass::BOUND_COLUMN_REF:
-		result = BoundColumnRefExpression::Deserialize(state, reader);
-		break;
-	case ExpressionClass::BOUND_AGGREGATE:
-		result = BoundAggregateExpression::Deserialize(state, reader);
-		break;
-	case ExpressionClass::BOUND_BETWEEN:
-		result = BoundBetweenExpression::Deserialize(state, reader);
-		break;
-	case ExpressionClass::BOUND_CONSTANT:
-		result = BoundConstantExpression::Deserialize(state, reader);
-		break;
-	case ExpressionClass::BOUND_DEFAULT:
-		result = BoundDefaultExpression::Deserialize(state, reader);
-		break;
-	case ExpressionClass::BOUND_FUNCTION:
-		result = BoundFunctionExpression::Deserialize(state, reader);
-		break;
-	case ExpressionClass::BOUND_CAST:
-		result = BoundCastExpression::Deserialize(state, reader);
-		break;
-	case ExpressionClass::BOUND_CASE:
-		result = BoundCaseExpression::Deserialize(state, reader);
-		break;
-	case ExpressionClass::BOUND_CONJUNCTION:
-		result = BoundConjunctionExpression::Deserialize(state, reader);
-		break;
-	case ExpressionClass::BOUND_COMPARISON:
-		result = BoundComparisonExpression::Deserialize(state, reader);
-		break;
-	case ExpressionClass::BOUND_OPERATOR:
-		result = BoundOperatorExpression::Deserialize(state, reader);
-		break;
-	case ExpressionClass::BOUND_WINDOW:
-		result = BoundWindowExpression::Deserialize(state, reader);
-		break;
-	case ExpressionClass::BOUND_UNNEST:
-		result = BoundUnnestExpression::Deserialize(state, reader);
-		break;
-	case ExpressionClass::BOUND_PARAMETER:
-		result = BoundParameterExpression::Deserialize(state, reader);
-		break;
-	default:
-		throw SerializationException("Unsupported type for expression deserialization %s",
-		                             ExpressionTypeToString(type));
-	}
-	result->alias = alias;
-	reader.Finalize();
-	return result;
-}
-
 bool Expression::Equals(const unique_ptr<Expression> &left, const unique_ptr<Expression> &right) {
 	if (left.get() == right.get()) {
 		return true;

package/src/duckdb/src/planner/filter/conjunction_filter.cpp

@@ -1,5 +1,4 @@
 #include "duckdb/planner/filter/conjunction_filter.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
@@ -47,16 +46,6 @@ bool ConjunctionOrFilter::Equals(const TableFilter &other_p) const {
 	return true;
 }
 
-void ConjunctionOrFilter::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializableList(child_filters);
-}
-
-unique_ptr<TableFilter> ConjunctionOrFilter::Deserialize(FieldReader &source) {
-	auto res = make_uniq<ConjunctionOrFilter>();
-	res->child_filters = source.ReadRequiredSerializableList<TableFilter>();
-	return std::move(res);
-}
-
 ConjunctionAndFilter::ConjunctionAndFilter() : ConjunctionFilter(TableFilterType::CONJUNCTION_AND) {
 }
 
@@ -102,14 +91,4 @@ bool ConjunctionAndFilter::Equals(const TableFilter &other_p) const {
 	return true;
 }
 
-void ConjunctionAndFilter::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializableList(child_filters);
-}
-
-unique_ptr<TableFilter> ConjunctionAndFilter::Deserialize(FieldReader &source) {
-	auto res = make_uniq<ConjunctionAndFilter>();
-	res->child_filters = source.ReadRequiredSerializableList<TableFilter>();
-	return std::move(res);
-}
-
 } // namespace duckdb

package/src/duckdb/src/planner/filter/constant_filter.cpp

@@ -1,6 +1,5 @@
 #include "duckdb/planner/filter/constant_filter.hpp"
 #include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
@@ -43,15 +42,4 @@ bool ConstantFilter::Equals(const TableFilter &other_p) const {
 	return other.comparison_type == comparison_type && other.constant == constant;
 }
 
-void ConstantFilter::Serialize(FieldWriter &writer) const {
-	writer.WriteField(comparison_type);
-	writer.WriteSerializable(constant);
-}
-
-unique_ptr<TableFilter> ConstantFilter::Deserialize(FieldReader &source) {
-	auto comparision_type = source.ReadRequired<ExpressionType>();
-	auto constant = source.ReadRequiredSerializable<Value, Value>();
-	return make_uniq<ConstantFilter>(comparision_type, constant);
-}
-
 } // namespace duckdb