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

package/src/duckdb/src/planner/operator/logical_delete.cpp

@@ -16,28 +16,6 @@ LogicalDelete::LogicalDelete(ClientContext &context, const string &catalog, cons
       table(Catalog::GetEntry<TableCatalogEntry>(context, catalog, schema, table)) {
 }
 
-void LogicalDelete::Serialize(FieldWriter &writer) const {
-	table.Serialize(writer.GetSerializer());
-	writer.WriteField(table_index);
-	writer.WriteField(return_chunk);
-	writer.WriteSerializableList(this->expressions);
-}
-
-unique_ptr<LogicalOperator> LogicalDelete::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto &context = state.gstate.context;
-	auto info = TableCatalogEntry::Deserialize(reader.GetSource());
-	auto &table_info = info->Cast<CreateTableInfo>();
-
-	auto &table_catalog_entry =
-	    Catalog::GetEntry<TableCatalogEntry>(context, info->catalog, info->schema, table_info.table);
-
-	auto table_index = reader.ReadRequired<idx_t>();
-	auto result = make_uniq<LogicalDelete>(table_catalog_entry, table_index);
-	result->return_chunk = reader.ReadRequired<bool>();
-	result->expressions = reader.ReadRequiredSerializableList<duckdb::Expression>(state.gstate);
-	return std::move(result);
-}
-
 idx_t LogicalDelete::EstimateCardinality(ClientContext &context) {
 	return return_chunk ? LogicalOperator::EstimateCardinality(context) : 1;
 }

package/src/duckdb/src/planner/operator/logical_delim_get.cpp

@@ -1,21 +1,9 @@
 #include "duckdb/planner/operator/logical_delim_get.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
-void LogicalDelimGet::Serialize(FieldWriter &writer) const {
-	writer.WriteField(table_index);
-	writer.WriteRegularSerializableList(chunk_types);
-}
-
-unique_ptr<LogicalOperator> LogicalDelimGet::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto table_index = reader.ReadRequired<idx_t>();
-	auto chunk_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	return make_uniq<LogicalDelimGet>(table_index, chunk_types);
-}
-
 vector<idx_t> LogicalDelimGet::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }

package/src/duckdb/src/planner/operator/logical_dependent_join.cpp

@@ -19,8 +19,4 @@ unique_ptr<LogicalOperator> LogicalDependentJoin::Create(unique_ptr<LogicalOpera
 	                                       std::move(condition));
 }
 
-void LogicalDependentJoin::Serialize(FieldWriter &writer) const {
-	throw InternalException("LogicalDependentJoin should not exist in any plan");
-}
-
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_distinct.cpp

@@ -1,4 +1,3 @@
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/planner/operator/logical_distinct.hpp"
 
@@ -22,21 +21,6 @@ string LogicalDistinct::ParamsToString() const {
 	return result;
 }
 
-void LogicalDistinct::Serialize(FieldWriter &writer) const {
-	writer.WriteField<DistinctType>(distinct_type);
-	writer.WriteSerializableList(distinct_targets);
-	writer.WriteOptional(order_by);
-}
-
-unique_ptr<LogicalOperator> LogicalDistinct::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto distinct_type = reader.ReadRequired<DistinctType>();
-	auto distinct_targets = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-	auto order_by = reader.ReadOptional<BoundOrderModifier>(nullptr, state.gstate);
-	auto ret = make_uniq<LogicalDistinct>(std::move(distinct_targets), distinct_type);
-	ret->order_by = std::move(order_by);
-	return std::move(ret);
-}
-
 void LogicalDistinct::ResolveTypes() {
 	types = children[0]->types;
 }

package/src/duckdb/src/planner/operator/logical_dummy_scan.cpp

@@ -1,19 +1,9 @@
 #include "duckdb/planner/operator/logical_dummy_scan.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
-void LogicalDummyScan::Serialize(FieldWriter &writer) const {
-	writer.WriteField(table_index);
-}
-
-unique_ptr<LogicalOperator> LogicalDummyScan::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto table_index = reader.ReadRequired<idx_t>();
-	return make_uniq<LogicalDummyScan>(table_index);
-}
-
 vector<idx_t> LogicalDummyScan::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }

package/src/duckdb/src/planner/operator/logical_empty_result.cpp

@@ -1,4 +1,3 @@
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/planner/operator/logical_empty_result.hpp"
 
 namespace duckdb {
@@ -15,18 +14,4 @@ LogicalEmptyResult::LogicalEmptyResult(unique_ptr<LogicalOperator> op)
 LogicalEmptyResult::LogicalEmptyResult() : LogicalOperator(LogicalOperatorType::LOGICAL_EMPTY_RESULT) {
 }
 
-void LogicalEmptyResult::Serialize(FieldWriter &writer) const {
-	writer.WriteRegularSerializableList(return_types);
-	writer.WriteList<ColumnBinding>(bindings);
-}
-
-unique_ptr<LogicalOperator> LogicalEmptyResult::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto return_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	auto bindings = reader.ReadRequiredList<ColumnBinding>();
-	auto result = unique_ptr<LogicalEmptyResult>(new LogicalEmptyResult());
-	result->return_types = return_types;
-	result->bindings = bindings;
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_expression_get.cpp

@@ -1,33 +1,9 @@
 #include "duckdb/planner/operator/logical_expression_get.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
-void LogicalExpressionGet::Serialize(FieldWriter &writer) const {
-	writer.WriteField(table_index);
-	writer.WriteRegularSerializableList(expr_types);
-
-	writer.WriteField<idx_t>(expressions.size());
-	for (auto &entry : expressions) {
-		writer.WriteSerializableList(entry);
-	}
-}
-
-unique_ptr<LogicalOperator> LogicalExpressionGet::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto table_index = reader.ReadRequired<idx_t>();
-	auto expr_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-
-	auto expressions_size = reader.ReadRequired<idx_t>();
-	vector<vector<unique_ptr<Expression>>> expressions;
-	for (idx_t i = 0; i < expressions_size; i++) {
-		expressions.push_back(reader.ReadRequiredSerializableList<Expression>(state.gstate));
-	}
-
-	return make_uniq<LogicalExpressionGet>(table_index, expr_types, std::move(expressions));
-}
-
 vector<idx_t> LogicalExpressionGet::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }

package/src/duckdb/src/planner/operator/logical_extension_operator.cpp

@@ -1,23 +1,10 @@
 #include "duckdb/planner/operator/logical_extension_operator.hpp"
 #include "duckdb/execution/column_binding_resolver.hpp"
 #include "duckdb/main/config.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 {
-unique_ptr<LogicalExtensionOperator> LogicalExtensionOperator::Deserialize(LogicalDeserializationState &state,
-                                                                           FieldReader &reader) {
-	auto &config = DBConfig::GetConfig(state.gstate.context);
-
-	auto extension_name = reader.ReadRequired<std::string>();
-	for (auto &extension : config.operator_extensions) {
-		if (extension->GetName() == extension_name) {
-			return extension->Deserialize(state, reader);
-		}
-	}
-
-	throw SerializationException("No serialization method exists for extension: " + extension_name);
-}
 
 void LogicalExtensionOperator::ResolveColumnBindings(ColumnBindingResolver &res, vector<ColumnBinding> &bindings) {
 	// general case
@@ -33,17 +20,17 @@ void LogicalExtensionOperator::ResolveColumnBindings(ColumnBindingResolver &res,
 	bindings = GetColumnBindings();
 }
 
-void LogicalExtensionOperator::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalExtensionOperator::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "extension_name", GetExtensionName());
 }
 
-unique_ptr<LogicalOperator> LogicalExtensionOperator::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalExtensionOperator::Deserialize(Deserializer &deserializer) {
 	auto &config = DBConfig::GetConfig(deserializer.Get<ClientContext &>());
 	auto extension_name = deserializer.ReadProperty<string>(200, "extension_name");
 	for (auto &extension : config.operator_extensions) {
 		if (extension->GetName() == extension_name) {
-			return extension->FormatDeserialize(deserializer);
+			return extension->Deserialize(deserializer);
 		}
 	}
 	throw SerializationException("No deserialization method exists for extension: " + extension_name);

package/src/duckdb/src/planner/operator/logical_filter.cpp

@@ -1,4 +1,3 @@
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/planner/operator/logical_filter.hpp"
 #include "duckdb/planner/expression/bound_conjunction_expression.hpp"
 
@@ -43,18 +42,4 @@ bool LogicalFilter::SplitPredicates(vector<unique_ptr<Expression>> &expressions)
 	return found_conjunction;
 }
 
-void LogicalFilter::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializableList<Expression>(expressions);
-	writer.WriteList<idx_t>(projection_map);
-}
-
-unique_ptr<LogicalOperator> LogicalFilter::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto expressions = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-	auto projection_map = reader.ReadRequiredList<idx_t>();
-	auto result = make_uniq<LogicalFilter>();
-	result->expressions = std::move(expressions);
-	result->projection_map = std::move(projection_map);
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_get.cpp

@@ -2,14 +2,13 @@
 
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/function/function_serialization.hpp"
 #include "duckdb/function/table/table_scan.hpp"
 #include "duckdb/main/config.hpp"
 #include "duckdb/storage/data_table.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 {
 
@@ -122,103 +121,17 @@ idx_t LogicalGet::EstimateCardinality(ClientContext &context) {
 	return 1;
 }
 
-void LogicalGet::Serialize(FieldWriter &writer) const {
-	writer.WriteField(table_index);
-	writer.WriteRegularSerializableList(returned_types);
-	writer.WriteList<string>(names);
-	writer.WriteList<column_t>(column_ids);
-	writer.WriteList<column_t>(projection_ids);
-	writer.WriteSerializable(table_filters);
-
-	FunctionSerializer::SerializeBase<TableFunction>(writer, function, bind_data.get());
-	if (!function.serialize) {
-		D_ASSERT(!function.deserialize);
-		// no serialize method: serialize input values and named_parameters for rebinding purposes
-		writer.WriteRegularSerializableList(parameters);
-		writer.WriteField<idx_t>(named_parameters.size());
-		for (auto &pair : named_parameters) {
-			writer.WriteString(pair.first);
-			writer.WriteSerializable(pair.second);
-		}
-		writer.WriteRegularSerializableList(input_table_types);
-		writer.WriteList<string>(input_table_names);
-	}
-	writer.WriteList<column_t>(projected_input);
-}
-
-unique_ptr<LogicalOperator> LogicalGet::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto table_index = reader.ReadRequired<idx_t>();
-	auto returned_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	auto returned_names = reader.ReadRequiredList<string>();
-	auto column_ids = reader.ReadRequiredList<column_t>();
-	auto projection_ids = reader.ReadRequiredList<column_t>();
-	auto table_filters = reader.ReadRequiredSerializable<TableFilterSet>();
-
-	unique_ptr<FunctionData> bind_data;
-	bool has_deserialize;
-	auto function = FunctionSerializer::DeserializeBaseInternal<TableFunction, TableFunctionCatalogEntry>(
-	    reader, state.gstate, CatalogType::TABLE_FUNCTION_ENTRY, bind_data, has_deserialize);
-
-	vector<Value> parameters;
-	named_parameter_map_t named_parameters;
-	vector<LogicalType> input_table_types;
-	vector<string> input_table_names;
-	if (!has_deserialize) {
-		D_ASSERT(!bind_data);
-		parameters = reader.ReadRequiredSerializableList<Value, Value>();
-
-		auto named_parameters_size = reader.ReadRequired<idx_t>();
-		for (idx_t i = 0; i < named_parameters_size; i++) {
-			auto first = reader.ReadRequired<string>();
-			auto second = reader.ReadRequiredSerializable<Value, Value>();
-			auto pair = make_pair(first, second);
-			named_parameters.insert(pair);
-		}
-
-		input_table_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-		input_table_names = reader.ReadRequiredList<string>();
-		TableFunctionBindInput input(parameters, named_parameters, input_table_types, input_table_names,
-		                             function.function_info.get());
-
-		vector<LogicalType> bind_return_types;
-		vector<string> bind_names;
-		bind_data = function.bind(state.gstate.context, input, bind_return_types, bind_names);
-		if (returned_types != bind_return_types) {
-			throw SerializationException(
-			    "Table function deserialization failure - bind returned different return types than were serialized");
-		}
-		// names can actually be different because of aliases - only the sizes cannot be different
-		if (returned_names.size() != bind_names.size()) {
-			throw SerializationException(
-			    "Table function deserialization failure - bind returned different returned names than were serialized");
-		}
-	}
-	vector<column_t> projected_input;
-	reader.ReadList<column_t>(projected_input);
-
-	auto result = make_uniq<LogicalGet>(table_index, function, std::move(bind_data), returned_types, returned_names);
-	result->column_ids = std::move(column_ids);
-	result->projection_ids = std::move(projection_ids);
-	result->table_filters = std::move(*table_filters);
-	result->parameters = std::move(parameters);
-	result->named_parameters = std::move(named_parameters);
-	result->input_table_types = input_table_types;
-	result->input_table_names = input_table_names;
-	result->projected_input = std::move(projected_input);
-	return std::move(result);
-}
-
-void LogicalGet::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalGet::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "table_index", table_index);
 	serializer.WriteProperty(201, "returned_types", returned_types);
 	serializer.WriteProperty(202, "names", names);
 	serializer.WriteProperty(203, "column_ids", column_ids);
 	serializer.WriteProperty(204, "projection_ids", projection_ids);
 	serializer.WriteProperty(205, "table_filters", table_filters);
-	FunctionSerializer::FormatSerialize(serializer, function, bind_data.get());
-	if (!function.format_serialize) {
-		D_ASSERT(!function.format_deserialize);
+	FunctionSerializer::Serialize(serializer, function, bind_data.get());
+	if (!function.serialize) {
+		D_ASSERT(!function.serialize);
 		// no serialize method: serialize input values and named_parameters for rebinding purposes
 		serializer.WriteProperty(206, "parameters", parameters);
 		serializer.WriteProperty(207, "named_parameters", named_parameters);
@@ -228,7 +141,7 @@ void LogicalGet::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(210, "projected_input", projected_input);
 }
 
-unique_ptr<LogicalOperator> LogicalGet::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalGet::Deserialize(Deserializer &deserializer) {
 	auto result = unique_ptr<LogicalGet>(new LogicalGet());
 	deserializer.ReadProperty(200, "table_index", result->table_index);
 	deserializer.ReadProperty(201, "returned_types", result->returned_types);
@@ -236,9 +149,10 @@ unique_ptr<LogicalOperator> LogicalGet::FormatDeserialize(FormatDeserializer &de
 	deserializer.ReadProperty(203, "column_ids", result->column_ids);
 	deserializer.ReadProperty(204, "projection_ids", result->projection_ids);
 	deserializer.ReadProperty(205, "table_filters", result->table_filters);
-	auto entry = FunctionSerializer::FormatDeserializeBase<TableFunction, TableFunctionCatalogEntry>(
+	auto entry = FunctionSerializer::DeserializeBase<TableFunction, TableFunctionCatalogEntry>(
 	    deserializer, CatalogType::TABLE_FUNCTION_ENTRY);
-	auto &function = entry.first;
+	result->function = entry.first;
+	auto &function = result->function;
 	auto has_serialize = entry.second;
 
 	unique_ptr<FunctionData> bind_data;
@@ -268,6 +182,7 @@ unique_ptr<LogicalOperator> LogicalGet::FormatDeserialize(FormatDeserializer &de
 	} else {
 		bind_data = FunctionSerializer::FunctionDeserialize(deserializer, function);
 	}
+	result->bind_data = std::move(bind_data);
 	deserializer.ReadProperty(210, "projected_input", result->projected_input);
 	return std::move(result);
 }

package/src/duckdb/src/planner/operator/logical_insert.cpp

@@ -1,7 +1,6 @@
 #include "duckdb/planner/operator/logical_insert.hpp"
 
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/main/config.hpp"
 #include "duckdb/parser/parsed_data/create_table_info.hpp"
 
@@ -17,82 +16,6 @@ LogicalInsert::LogicalInsert(ClientContext &context, const string &catalog, cons
       table(Catalog::GetEntry<TableCatalogEntry>(context, catalog, schema, table)) {
 }
 
-void LogicalInsert::Serialize(FieldWriter &writer) const {
-	writer.WriteField<idx_t>(insert_values.size());
-	for (auto &entry : insert_values) {
-		writer.WriteSerializableList(entry);
-	}
-
-	writer.WriteList<idx_t>(column_index_map);
-	writer.WriteRegularSerializableList(expected_types);
-	table.Serialize(writer.GetSerializer());
-	writer.WriteField(table_index);
-	writer.WriteField(return_chunk);
-	writer.WriteSerializableList(bound_defaults);
-	writer.WriteField(action_type);
-	writer.WriteRegularSerializableList(expected_set_types);
-	writer.WriteList<column_t>(on_conflict_filter);
-	writer.WriteOptional(on_conflict_condition);
-	writer.WriteOptional(do_update_condition);
-	writer.WriteIndexList(set_columns);
-	writer.WriteRegularSerializableList(set_types);
-	writer.WriteField(excluded_table_index);
-	writer.WriteList<column_t>(columns_to_fetch);
-	writer.WriteList<column_t>(source_columns);
-	writer.WriteSerializableList<Expression>(expressions);
-}
-
-unique_ptr<LogicalOperator> LogicalInsert::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto &context = state.gstate.context;
-	auto insert_values_size = reader.ReadRequired<idx_t>();
-	vector<vector<unique_ptr<Expression>>> insert_values;
-	for (idx_t i = 0; i < insert_values_size; ++i) {
-		insert_values.push_back(reader.ReadRequiredSerializableList<Expression>(state.gstate));
-	}
-
-	auto column_index_map = reader.ReadRequiredList<idx_t, physical_index_vector_t<idx_t>>();
-	auto expected_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	auto info = TableCatalogEntry::Deserialize(reader.GetSource());
-	auto table_index = reader.ReadRequired<idx_t>();
-	auto return_chunk = reader.ReadRequired<bool>();
-	auto bound_defaults = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-	auto action_type = reader.ReadRequired<OnConflictAction>();
-	auto expected_set_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	auto on_conflict_filter = reader.ReadRequiredSet<column_t, unordered_set<column_t>>();
-	auto on_conflict_condition = reader.ReadOptional<Expression>(nullptr, state.gstate);
-	auto do_update_condition = reader.ReadOptional<Expression>(nullptr, state.gstate);
-	auto set_columns = reader.ReadRequiredIndexList<PhysicalIndex>();
-	auto set_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	auto excluded_table_index = reader.ReadRequired<idx_t>();
-	auto columns_to_fetch = reader.ReadRequiredList<column_t>();
-	auto source_columns = reader.ReadRequiredList<column_t>();
-	auto expressions = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-
-	auto &catalog = Catalog::GetCatalog(context, info->catalog);
-
-	auto &table_catalog_entry =
-	    catalog.GetEntry<TableCatalogEntry>(context, info->schema, info->Cast<CreateTableInfo>().table);
-	auto result = make_uniq<LogicalInsert>(table_catalog_entry, table_index);
-	result->type = state.type;
-	result->return_chunk = return_chunk;
-	result->insert_values = std::move(insert_values);
-	result->column_index_map = column_index_map;
-	result->expected_types = expected_types;
-	result->bound_defaults = std::move(bound_defaults);
-	result->action_type = action_type;
-	result->expected_set_types = std::move(expected_set_types);
-	result->on_conflict_filter = std::move(on_conflict_filter);
-	result->on_conflict_condition = std::move(on_conflict_condition);
-	result->do_update_condition = std::move(do_update_condition);
-	result->set_columns = std::move(set_columns);
-	result->set_types = std::move(set_types);
-	result->excluded_table_index = excluded_table_index;
-	result->columns_to_fetch = std::move(columns_to_fetch);
-	result->source_columns = std::move(source_columns);
-	result->expressions = std::move(expressions);
-	return std::move(result);
-}
-
 idx_t LogicalInsert::EstimateCardinality(ClientContext &context) {
 	return return_chunk ? LogicalOperator::EstimateCardinality(context) : 1;
 }

package/src/duckdb/src/planner/operator/logical_join.cpp

@@ -2,7 +2,6 @@
 
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
@@ -59,20 +58,4 @@ void LogicalJoin::GetExpressionBindings(Expression &expr, unordered_set<idx_t> &
 	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { GetExpressionBindings(child, bindings); });
 }
 
-void LogicalJoin::Serialize(FieldWriter &writer) const {
-	writer.WriteField<JoinType>(join_type);
-	writer.WriteField<idx_t>(mark_index);
-	writer.WriteList<idx_t>(left_projection_map);
-	writer.WriteList<idx_t>(right_projection_map);
-	//	writer.WriteSerializableList(join_stats);
-}
-
-void LogicalJoin::Deserialize(LogicalJoin &join, LogicalDeserializationState &state, FieldReader &reader) {
-	join.join_type = reader.ReadRequired<JoinType>();
-	join.mark_index = reader.ReadRequired<idx_t>();
-	join.left_projection_map = reader.ReadRequiredList<idx_t>();
-	join.right_projection_map = reader.ReadRequiredList<idx_t>();
-	//	join.join_stats = reader.ReadRequiredSerializableList<BaseStatistics>(reader.GetSource());
-}
-
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_limit.cpp

@@ -1,4 +1,3 @@
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/planner/operator/logical_limit.hpp"
 
 namespace duckdb {
@@ -25,19 +24,4 @@ void LogicalLimit::ResolveTypes() {
 	types = children[0]->types;
 }
 
-void LogicalLimit::Serialize(FieldWriter &writer) const {
-	writer.WriteField(limit_val);
-	writer.WriteField(offset_val);
-	writer.WriteOptional(limit);
-	writer.WriteOptional(offset);
-}
-
-unique_ptr<LogicalOperator> LogicalLimit::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto limit_val = reader.ReadRequired<int64_t>();
-	auto offset_val = reader.ReadRequired<int64_t>();
-	auto limit = reader.ReadOptional<Expression>(nullptr, state.gstate);
-	auto offset = reader.ReadOptional<Expression>(nullptr, state.gstate);
-	return make_uniq<LogicalLimit>(limit_val, offset_val, std::move(limit), std::move(offset));
-}
-
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_limit_percent.cpp

@@ -1,24 +1,8 @@
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/planner/operator/logical_limit_percent.hpp"
 #include <cmath>
 
 namespace duckdb {
 
-void LogicalLimitPercent::Serialize(FieldWriter &writer) const {
-	writer.WriteField(limit_percent);
-	writer.WriteField(offset_val);
-	writer.WriteOptional(limit);
-	writer.WriteOptional(offset);
-}
-
-unique_ptr<LogicalOperator> LogicalLimitPercent::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto limit_percent = reader.ReadRequired<double>();
-	auto offset_val = reader.ReadRequired<int64_t>();
-	auto limit = reader.ReadOptional<Expression>(nullptr, state.gstate);
-	auto offset = reader.ReadOptional<Expression>(nullptr, state.gstate);
-	return make_uniq<LogicalLimitPercent>(limit_percent, offset_val, std::move(limit), std::move(offset));
-}
-
 idx_t LogicalLimitPercent::EstimateCardinality(ClientContext &context) {
 	auto child_cardinality = LogicalOperator::EstimateCardinality(context);
 	if ((limit_percent < 0 || limit_percent > 100) || std::isnan(limit_percent)) {

package/src/duckdb/src/planner/operator/logical_materialized_cte.cpp

@@ -1,20 +1,7 @@
 #include "duckdb/planner/operator/logical_materialized_cte.hpp"
 
-#include "duckdb/common/field_writer.hpp"
-
 namespace duckdb {
 
-void LogicalMaterializedCTE::Serialize(FieldWriter &writer) const {
-	writer.WriteField(table_index);
-}
-
-unique_ptr<LogicalOperator> LogicalMaterializedCTE::Deserialize(LogicalDeserializationState &state,
-                                                                FieldReader &reader) {
-	auto result = unique_ptr<LogicalMaterializedCTE>(new LogicalMaterializedCTE());
-	result->table_index = reader.ReadRequired<idx_t>();
-	return std::move(result);
-}
-
 vector<idx_t> LogicalMaterializedCTE::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }

package/src/duckdb/src/planner/operator/logical_order.cpp

@@ -1,7 +1,5 @@
 #include "duckdb/planner/operator/logical_order.hpp"
 
-#include "duckdb/common/field_writer.hpp"
-
 namespace duckdb {
 
 LogicalOrder::LogicalOrder(vector<BoundOrderByNode> orders)
@@ -43,17 +41,4 @@ void LogicalOrder::ResolveTypes() {
 	}
 }
 
-void LogicalOrder::Serialize(FieldWriter &writer) const {
-	writer.WriteRegularSerializableList(orders);
-	writer.WriteList<idx_t>(projections);
-}
-
-unique_ptr<LogicalOperator> LogicalOrder::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto orders = reader.ReadRequiredSerializableList<BoundOrderByNode, BoundOrderByNode>(state.gstate);
-	auto projections = reader.ReadRequiredList<idx_t>();
-	auto result = make_uniq<LogicalOrder>(std::move(orders));
-	result->projections = std::move(projections);
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_pivot.cpp

@@ -21,26 +21,6 @@ vector<ColumnBinding> LogicalPivot::GetColumnBindings() {
 	return result;
 }
 
-void LogicalPivot::Serialize(FieldWriter &writer) const {
-	writer.WriteField(pivot_index);
-	writer.WriteOptional<LogicalOperator>(children.back());
-	writer.WriteField(bound_pivot.group_count);
-	writer.WriteRegularSerializableList<LogicalType>(bound_pivot.types);
-	writer.WriteList<string>(bound_pivot.pivot_values);
-	writer.WriteSerializableList<Expression>(bound_pivot.aggregates);
-}
-
-unique_ptr<LogicalOperator> LogicalPivot::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto pivot_index = reader.ReadRequired<idx_t>();
-	auto plan = reader.ReadOptional<LogicalOperator>(nullptr, state.gstate);
-	BoundPivotInfo info;
-	info.group_count = reader.ReadRequired<idx_t>();
-	info.types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	info.pivot_values = reader.ReadRequiredList<string>();
-	info.aggregates = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-	return make_uniq<LogicalPivot>(pivot_index, std::move(plan), std::move(info));
-}
-
 vector<idx_t> LogicalPivot::GetTableIndex() const {
 	return vector<idx_t> {pivot_index};
 }

package/src/duckdb/src/planner/operator/logical_positional_join.cpp

@@ -17,14 +17,4 @@ unique_ptr<LogicalOperator> LogicalPositionalJoin::Create(unique_ptr<LogicalOper
 	return make_uniq<LogicalPositionalJoin>(std::move(left), std::move(right));
 }
 
-void LogicalPositionalJoin::Serialize(FieldWriter &writer) const {
-}
-
-unique_ptr<LogicalOperator> LogicalPositionalJoin::Deserialize(LogicalDeserializationState &state,
-                                                               FieldReader &reader) {
-	// TODO(stephwang): review if unique_ptr<LogicalOperator> plan is needed
-	auto result = unique_ptr<LogicalPositionalJoin>(new LogicalPositionalJoin());
-	return std::move(result);
-}
-
 } // namespace duckdb