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

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

@@ -41,18 +41,4 @@ string IsNotNullFilter::ToString(const string &column_name) {
 	return column_name + " IS NOT NULL";
 }
 
-void IsNotNullFilter::Serialize(FieldWriter &writer) const {
-}
-
-unique_ptr<TableFilter> IsNotNullFilter::Deserialize(FieldReader &source) {
-	return make_uniq<IsNotNullFilter>();
-}
-
-void IsNullFilter::Serialize(FieldWriter &writer) const {
-}
-
-unique_ptr<TableFilter> IsNullFilter::Deserialize(FieldReader &source) {
-	return make_uniq<IsNullFilter>();
-}
-
 } // namespace duckdb

package/src/duckdb/src/planner/joinside.cpp

@@ -5,7 +5,6 @@
 #include "duckdb/planner/expression/bound_conjunction_expression.hpp"
 #include "duckdb/planner/expression/bound_subquery_expression.hpp"
 #include "duckdb/planner/expression_iterator.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
@@ -30,29 +29,6 @@ unique_ptr<Expression> JoinCondition::CreateExpression(vector<JoinCondition> con
 	return result;
 }
 
-//! Serializes a JoinCondition to a stand-alone binary blob
-void JoinCondition::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteOptional(left);
-	writer.WriteOptional(right);
-	writer.WriteField<ExpressionType>(comparison);
-	writer.Finalize();
-}
-
-//! Deserializes a blob back into a JoinCondition
-JoinCondition JoinCondition::Deserialize(Deserializer &source, PlanDeserializationState &state) {
-	auto result = JoinCondition();
-
-	FieldReader reader(source);
-	auto left = reader.ReadOptional<Expression>(nullptr, state);
-	auto right = reader.ReadOptional<Expression>(nullptr, state);
-	result.left = std::move(left);
-	result.right = std::move(right);
-	result.comparison = reader.ReadRequired<ExpressionType>();
-	reader.Finalize();
-	return result;
-}
-
 JoinSide JoinSide::CombineJoinSide(JoinSide left, JoinSide right) {
 	if (left == JoinSide::NONE) {
 		return right;

package/src/duckdb/src/planner/logical_operator.cpp

@@ -1,21 +1,16 @@
 #include "duckdb/planner/logical_operator.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/printer.hpp"
-#include "duckdb/common/serializer/buffered_deserializer.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/tree_renderer.hpp"
 #include "duckdb/parser/parser.hpp"
 #include "duckdb/planner/operator/list.hpp"
-#include "duckdb/planner/operator/logical_extension_operator.hpp"
-#include "duckdb/planner/operator/logical_dependent_join.hpp"
 #include "duckdb/common/serializer/binary_serializer.hpp"
 #include "duckdb/common/serializer/binary_deserializer.hpp"
+#include "duckdb/common/serializer/memory_stream.hpp"
 
 namespace duckdb {
 
-const uint64_t PLAN_SERIALIZATION_VERSION = 1;
-
 LogicalOperator::LogicalOperator(LogicalOperatorType type)
     : type(type), estimated_cardinality(0), has_estimated_cardinality(false) {
 }
@@ -129,30 +124,20 @@ void LogicalOperator::Verify(ClientContext &context) {
 		if (expressions[expr_idx]->HasParameter()) {
 			continue;
 		}
-		BufferedSerializer serializer;
+		MemoryStream stream;
 		// We are serializing a query plan
 		try {
-			expressions[expr_idx]->Serialize(serializer);
+			BinarySerializer::Serialize(*expressions[expr_idx], stream);
 		} catch (NotImplementedException &ex) {
 			// ignore for now (FIXME)
 			continue;
 		}
+		// Rewind the stream
+		stream.Rewind();
 
-		auto data = serializer.GetData();
-		auto deserializer = BufferedContextDeserializer(context, data.data.get(), data.size);
-
-		PlanDeserializationState state(context);
-		auto deserialized_expression = Expression::Deserialize(deserializer, state);
+		bound_parameter_map_t parameters;
+		auto deserialized_expression = BinaryDeserializer::Deserialize<Expression>(stream, context, parameters);
 
-		// format (de)serialization of expressions
-		try {
-			auto blob = BinarySerializer::Serialize(*expressions[expr_idx], true);
-			bound_parameter_map_t parameters;
-			auto result = BinaryDeserializer::Deserialize<Expression>(context, parameters, blob.data(), blob.size());
-			result->Hash();
-		} catch (SerializationException &ex) {
-			// pass
-		}
 		// FIXME: expressions might not be equal yet because of statistics propagation
 		continue;
 		D_ASSERT(Expression::Equals(expressions[expr_idx], deserialized_expression));
@@ -188,210 +173,25 @@ void LogicalOperator::Print() {
 	Printer::Print(ToString());
 }
 
-void LogicalOperator::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField<LogicalOperatorType>(type);
-	writer.WriteSerializableList(children);
-
-	Serialize(writer);
-	writer.Finalize();
-}
-
-unique_ptr<LogicalOperator> LogicalOperator::Deserialize(Deserializer &deserializer, PlanDeserializationState &gstate) {
-	unique_ptr<LogicalOperator> result;
-
-	FieldReader reader(deserializer);
-	auto type = reader.ReadRequired<LogicalOperatorType>();
-	auto children = reader.ReadRequiredSerializableList<LogicalOperator>(gstate);
-
-	LogicalDeserializationState state(gstate, type, children);
-	switch (type) {
-	case LogicalOperatorType::LOGICAL_PROJECTION:
-		result = LogicalProjection::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_FILTER:
-		result = LogicalFilter::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY:
-		result = LogicalAggregate::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_WINDOW:
-		result = LogicalWindow::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_UNNEST:
-		result = LogicalUnnest::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_LIMIT:
-		result = LogicalLimit::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_ORDER_BY:
-		result = LogicalOrder::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_TOP_N:
-		result = LogicalTopN::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_COPY_TO_FILE:
-		result = LogicalCopyToFile::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_DISTINCT:
-		result = LogicalDistinct::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_SAMPLE:
-		result = LogicalSample::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_LIMIT_PERCENT:
-		result = LogicalLimitPercent::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_GET:
-		result = LogicalGet::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_CHUNK_GET:
-		result = LogicalColumnDataGet::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_DELIM_GET:
-		result = LogicalDelimGet::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_EXPRESSION_GET:
-		result = LogicalExpressionGet::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_DUMMY_SCAN:
-		result = LogicalDummyScan::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_EMPTY_RESULT:
-		result = LogicalEmptyResult::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_CTE_REF:
-		result = LogicalCTERef::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_JOIN:
-		throw InternalException("LogicalJoin deserialize not supported");
-	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
-		result = LogicalComparisonJoin::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_ANY_JOIN:
-		result = LogicalAnyJoin::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
-		result = LogicalCrossProduct::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_POSITIONAL_JOIN:
-		result = LogicalPositionalJoin::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_UNION:
-		result = LogicalSetOperation::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_EXCEPT:
-		result = LogicalSetOperation::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_INTERSECT:
-		result = LogicalSetOperation::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_RECURSIVE_CTE:
-		result = LogicalRecursiveCTE::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_MATERIALIZED_CTE:
-		result = LogicalMaterializedCTE::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_INSERT:
-		result = LogicalInsert::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_DELETE:
-		result = LogicalDelete::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_UPDATE:
-		result = LogicalUpdate::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_CREATE_TABLE:
-		result = LogicalCreateTable::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_CREATE_INDEX:
-		result = LogicalCreateIndex::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_CREATE_SEQUENCE:
-		result = LogicalCreate::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_CREATE_VIEW:
-		result = LogicalCreate::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_CREATE_SCHEMA:
-		result = LogicalCreate::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_CREATE_MACRO:
-		result = LogicalCreate::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_PRAGMA:
-		result = LogicalPragma::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_CREATE_TYPE:
-		result = LogicalCreate::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_EXPLAIN:
-		result = LogicalExplain::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_SHOW:
-		result = LogicalShow::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_PREPARE:
-		result = LogicalPrepare::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_EXECUTE:
-		result = LogicalExecute::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_EXPORT:
-		result = LogicalExport::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_SET:
-		result = LogicalSet::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_RESET:
-		result = LogicalReset::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_ALTER:
-	case LogicalOperatorType::LOGICAL_VACUUM:
-	case LogicalOperatorType::LOGICAL_LOAD:
-	case LogicalOperatorType::LOGICAL_ATTACH:
-	case LogicalOperatorType::LOGICAL_TRANSACTION:
-	case LogicalOperatorType::LOGICAL_DROP:
-	case LogicalOperatorType::LOGICAL_DETACH:
-		result = LogicalSimple::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR:
-		result = LogicalExtensionOperator::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_PIVOT:
-		result = LogicalPivot::Deserialize(state, reader);
-		break;
-	case LogicalOperatorType::LOGICAL_DEPENDENT_JOIN:
-	case LogicalOperatorType::LOGICAL_INVALID:
-		/* no default here to trigger a warning if we forget to implement deserialize for a new operator */
-		throw SerializationException("Invalid type for operator deserialization");
-	}
-
-	reader.Finalize();
-	result->children = std::move(children);
-
-	return result;
-}
-
 vector<idx_t> LogicalOperator::GetTableIndex() const {
 	return vector<idx_t> {};
 }
 
 unique_ptr<LogicalOperator> LogicalOperator::Copy(ClientContext &context) const {
-	BufferedSerializer logical_op_serializer;
+	MemoryStream stream;
+	BinarySerializer serializer(stream);
 	try {
-		this->Serialize(logical_op_serializer);
+		serializer.Begin();
+		this->Serialize(serializer);
+		serializer.End();
 	} catch (NotImplementedException &ex) {
 		throw NotImplementedException("Logical Operator Copy requires the logical operator and all of its children to "
 		                              "be serializable: " +
 		                              std::string(ex.what()));
 	}
-	auto data = logical_op_serializer.GetData();
-	auto logical_op_deserializer = BufferedContextDeserializer(context, data.data.get(), data.size);
-	PlanDeserializationState state(context);
-	auto op_copy = LogicalOperator::Deserialize(logical_op_deserializer, state);
+	stream.Rewind();
+	bound_parameter_map_t parameters;
+	auto op_copy = BinaryDeserializer::Deserialize<LogicalOperator>(stream, context, parameters);
 	return op_copy;
 }
 

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

@@ -1,6 +1,5 @@
 #include "duckdb/planner/operator/logical_aggregate.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/main/config.hpp"
 
@@ -58,51 +57,6 @@ string LogicalAggregate::ParamsToString() const {
 	return result;
 }
 
-void LogicalAggregate::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializableList(expressions);
-
-	writer.WriteField(group_index);
-	writer.WriteField(aggregate_index);
-	writer.WriteField(groupings_index);
-	writer.WriteSerializableList(groups);
-	writer.WriteField<idx_t>(grouping_sets.size());
-	for (auto &entry : grouping_sets) {
-		writer.WriteList<idx_t>(entry);
-	}
-	writer.WriteField<idx_t>(grouping_functions.size());
-	for (auto &entry : grouping_functions) {
-		writer.WriteList<idx_t>(entry);
-	}
-
-	// TODO statistics
-}
-
-unique_ptr<LogicalOperator> LogicalAggregate::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto expressions = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-
-	auto group_index = reader.ReadRequired<idx_t>();
-	auto aggregate_index = reader.ReadRequired<idx_t>();
-	auto groupings_index = reader.ReadRequired<idx_t>();
-	auto groups = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-	auto grouping_sets_size = reader.ReadRequired<idx_t>();
-	vector<GroupingSet> grouping_sets;
-	for (idx_t i = 0; i < grouping_sets_size; i++) {
-		grouping_sets.push_back(reader.ReadRequiredSet<idx_t>());
-	}
-	vector<unsafe_vector<idx_t>> grouping_functions;
-	auto grouping_functions_size = reader.ReadRequired<idx_t>();
-	for (idx_t i = 0; i < grouping_functions_size; i++) {
-		grouping_functions.push_back(reader.ReadRequiredList<idx_t>());
-	}
-	auto result = make_uniq<LogicalAggregate>(group_index, aggregate_index, std::move(expressions));
-	result->groupings_index = groupings_index;
-	result->groups = std::move(groups);
-	result->grouping_functions = std::move(grouping_functions);
-	result->grouping_sets = std::move(grouping_sets);
-
-	return std::move(result);
-}
-
 idx_t LogicalAggregate::EstimateCardinality(ClientContext &context) {
 	if (groups.empty()) {
 		// ungrouped aggregate

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

@@ -1,5 +1,4 @@
 #include "duckdb/planner/operator/logical_any_join.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
@@ -10,17 +9,4 @@ string LogicalAnyJoin::ParamsToString() const {
 	return condition->ToString();
 }
 
-void LogicalAnyJoin::Serialize(FieldWriter &writer) const {
-	writer.WriteField(join_type);
-	writer.WriteOptional(condition);
-}
-
-unique_ptr<LogicalOperator> LogicalAnyJoin::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto join_type = reader.ReadRequired<JoinType>();
-	auto condition = reader.ReadOptional<Expression>(nullptr, state.gstate);
-	auto result = make_uniq<LogicalAnyJoin>(join_type);
-	result->condition = std::move(condition);
-	return std::move(result);
-}
-
 } // namespace duckdb

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

@@ -1,6 +1,5 @@
 #include "duckdb/planner/operator/logical_column_data_get.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/main/config.hpp"
 
@@ -18,28 +17,6 @@ vector<ColumnBinding> LogicalColumnDataGet::GetColumnBindings() {
 	return GenerateColumnBindings(table_index, chunk_types.size());
 }
 
-void LogicalColumnDataGet::Serialize(FieldWriter &writer) const {
-	writer.WriteField(table_index);
-	writer.WriteRegularSerializableList(chunk_types);
-	writer.WriteField(collection->ChunkCount());
-	for (auto &chunk : collection->Chunks()) {
-		chunk.Serialize(writer.GetSerializer());
-	}
-}
-
-unique_ptr<LogicalOperator> LogicalColumnDataGet::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto table_index = reader.ReadRequired<idx_t>();
-	auto chunk_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	auto chunk_count = reader.ReadRequired<idx_t>();
-	auto collection = make_uniq<ColumnDataCollection>(state.gstate.context, chunk_types);
-	for (idx_t i = 0; i < chunk_count; i++) {
-		DataChunk chunk;
-		chunk.Deserialize(reader.GetSource());
-		collection->Append(chunk);
-	}
-	return make_uniq<LogicalColumnDataGet>(table_index, std::move(chunk_types), std::move(collection));
-}
-
 vector<idx_t> LogicalColumnDataGet::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }

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

@@ -1,4 +1,3 @@
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
 #include "duckdb/planner/expression/bound_comparison_expression.hpp"
@@ -21,26 +20,4 @@ string LogicalComparisonJoin::ParamsToString() const {
 	return result;
 }
 
-void LogicalComparisonJoin::Serialize(FieldWriter &writer) const {
-	LogicalJoin::Serialize(writer);
-	writer.WriteRegularSerializableList(mark_types);
-	writer.WriteRegularSerializableList(conditions);
-	writer.WriteSerializableList(duplicate_eliminated_columns);
-}
-
-void LogicalComparisonJoin::Deserialize(LogicalComparisonJoin &comparison_join, LogicalDeserializationState &state,
-                                        FieldReader &reader) {
-	LogicalJoin::Deserialize(comparison_join, state, reader);
-	comparison_join.mark_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	comparison_join.conditions = reader.ReadRequiredSerializableList<JoinCondition, JoinCondition>(state.gstate);
-	comparison_join.duplicate_eliminated_columns = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-}
-
-unique_ptr<LogicalOperator> LogicalComparisonJoin::Deserialize(LogicalDeserializationState &state,
-                                                               FieldReader &reader) {
-	auto result = make_uniq<LogicalComparisonJoin>(JoinType::INVALID, state.type);
-	LogicalComparisonJoin::Deserialize(*result, state, reader);
-	return std::move(result);
-}
-
 } // namespace duckdb

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

@@ -1,69 +1,15 @@
 #include "duckdb/planner/operator/logical_copy_to_file.hpp"
 
 #include "duckdb/catalog/catalog_entry/copy_function_catalog_entry.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/function/copy_function.hpp"
 
 namespace duckdb {
 
-// Warning: some fields here were added while this code appears untested
-// -> copy test in test/api/test_plan_serialization.cpp was commented out as WIP
-void LogicalCopyToFile::Serialize(FieldWriter &writer) const {
-	writer.WriteString(file_path);
-	writer.WriteField(use_tmp_file);
-	writer.WriteField(overwrite_or_ignore);
-	writer.WriteField(per_thread_output);
-	writer.WriteList<idx_t>(partition_columns);
-
-	D_ASSERT(!function.name.empty());
-	writer.WriteString(function.name);
-
-	writer.WriteField(bind_data != nullptr);
-	if (bind_data && !function.serialize) {
-		throw InvalidInputException("Can't serialize copy function %s", function.name);
-	}
-
-	function.serialize(writer, *bind_data, function);
-}
-
-unique_ptr<LogicalOperator> LogicalCopyToFile::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto file_path = reader.ReadRequired<string>();
-	auto use_tmp_file = reader.ReadRequired<bool>();
-	auto overwrite_or_ignore = reader.ReadRequired<bool>();
-	auto per_thread_output = reader.ReadRequired<bool>();
-	auto partition_columns = reader.ReadRequiredList<idx_t>();
-
-	auto copy_func_name = reader.ReadRequired<string>();
-
-	auto has_bind_data = reader.ReadRequired<bool>();
-
-	auto &context = state.gstate.context;
-	auto &copy_func_catalog_entry =
-	    Catalog::GetEntry<CopyFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, copy_func_name);
-	auto &copy_func = copy_func_catalog_entry.function;
-
-	unique_ptr<FunctionData> bind_data;
-	if (has_bind_data) {
-		if (!copy_func.deserialize) {
-			throw SerializationException("Have bind info but no deserialization function for %s", copy_func.name);
-		}
-		bind_data = copy_func.deserialize(context, reader, copy_func);
-	}
-
-	auto result = make_uniq<LogicalCopyToFile>(copy_func, std::move(bind_data));
-	result->file_path = file_path;
-	result->use_tmp_file = use_tmp_file;
-	result->overwrite_or_ignore = overwrite_or_ignore;
-	result->per_thread_output = per_thread_output;
-	result->partition_columns = std::move(partition_columns);
-	return std::move(result);
-}
-
-void LogicalCopyToFile::FormatSerialize(FormatSerializer &serializer) const {
+void LogicalCopyToFile::Serialize(Serializer &serializer) const {
 	throw SerializationException("LogicalCopyToFile not implemented yet");
 }
 
-unique_ptr<LogicalOperator> LogicalCopyToFile::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalCopyToFile::Deserialize(Deserializer &deserializer) {
 	throw SerializationException("LogicalCopyToFile not implemented yet");
 }
 

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

@@ -12,18 +12,6 @@ LogicalCreate::LogicalCreate(LogicalOperatorType type, ClientContext &context, u
 	this->schema = Catalog::GetSchema(context, info->catalog, info->schema, OnEntryNotFound::RETURN_NULL);
 }
 
-void LogicalCreate::Serialize(FieldWriter &writer) const {
-	info->Serialize(writer.GetSerializer());
-}
-
-unique_ptr<LogicalOperator> LogicalCreate::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto &context = state.gstate.context;
-	auto info = CreateInfo::Deserialize(reader.GetSource());
-
-	auto schema_catalog_entry = Catalog::GetSchema(context, info->catalog, info->schema, OnEntryNotFound::RETURN_NULL);
-	return make_uniq<LogicalCreate>(state.type, std::move(info), schema_catalog_entry);
-}
-
 idx_t LogicalCreate::EstimateCardinality(ClientContext &context) {
 	return 1;
 }

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

@@ -30,31 +30,6 @@ LogicalCreateIndex::LogicalCreateIndex(ClientContext &context, unique_ptr<Create
 	this->expressions = std::move(expressions_p);
 }
 
-void LogicalCreateIndex::Serialize(FieldWriter &writer) const {
-	writer.WriteOptional(info);
-	writer.WriteString(table.catalog.GetName());
-	writer.WriteString(table.schema.name);
-	writer.WriteString(table.name);
-	writer.WriteSerializableList(unbound_expressions);
-}
-
-unique_ptr<LogicalOperator> LogicalCreateIndex::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto &context = state.gstate.context;
-
-	auto info = reader.ReadOptional<CreateInfo>(nullptr);
-	auto catalog = reader.ReadRequired<string>();
-	auto schema = reader.ReadRequired<string>();
-	auto table_name = reader.ReadRequired<string>();
-	auto unbound_expressions = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-	if (info->type != CatalogType::INDEX_ENTRY) {
-		throw InternalException("Unexpected type: '%s', expected '%s'", CatalogTypeToString(info->type),
-		                        CatalogTypeToString(CatalogType::INDEX_ENTRY));
-	}
-	auto index_info = unique_ptr_cast<CreateInfo, CreateIndexInfo>(std::move(info));
-	auto &table = Catalog::GetEntry<TableCatalogEntry>(context, catalog, schema, table_name);
-	return make_uniq<LogicalCreateIndex>(std::move(index_info), std::move(unbound_expressions), table);
-}
-
 void LogicalCreateIndex::ResolveTypes() {
 	types.emplace_back(LogicalType::BIGINT);
 }

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

@@ -14,16 +14,6 @@ LogicalCreateTable::LogicalCreateTable(ClientContext &context, const string &cat
 	info = binder->BindCreateTableInfo(unique_ptr_cast<CreateInfo, CreateTableInfo>(std::move(unbound_info)));
 }
 
-void LogicalCreateTable::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*info);
-}
-
-unique_ptr<LogicalOperator> LogicalCreateTable::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto info = reader.ReadRequiredSerializable<BoundCreateTableInfo>(state.gstate);
-	auto &schema = info->schema;
-	return make_uniq<LogicalCreateTable>(schema, std::move(info));
-}
-
 idx_t LogicalCreateTable::EstimateCardinality(ClientContext &context) {
 	return 1;
 }

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

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

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

@@ -1,27 +1,9 @@
 #include "duckdb/planner/operator/logical_cteref.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
-void LogicalCTERef::Serialize(FieldWriter &writer) const {
-	writer.WriteField(table_index);
-	writer.WriteField(cte_index);
-	writer.WriteRegularSerializableList(chunk_types);
-	writer.WriteList<string>(bound_columns);
-	writer.WriteField(materialized_cte);
-}
-
-unique_ptr<LogicalOperator> LogicalCTERef::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto table_index = reader.ReadRequired<idx_t>();
-	auto cte_index = reader.ReadRequired<idx_t>();
-	auto chunk_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	auto bound_columns = reader.ReadRequiredList<string>();
-	auto materialized_cte = reader.ReadField<CTEMaterialize>(CTEMaterialize::CTE_MATERIALIZE_DEFAULT);
-	return make_uniq<LogicalCTERef>(table_index, cte_index, chunk_types, bound_columns, materialized_cte);
-}
-
 vector<idx_t> LogicalCTERef::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }