duckdb 0.8.2-dev87.0 → 0.9.1-dev0.0

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"
 
@@ -12,79 +11,10 @@ LogicalInsert::LogicalInsert(TableCatalogEntry &table, idx_t table_index)
       action_type(OnConflictAction::THROW) {
 }
 
-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(), context);
-	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->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);
+LogicalInsert::LogicalInsert(ClientContext &context, const unique_ptr<CreateInfo> table_info)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_INSERT),
+      table(Catalog::GetEntry<TableCatalogEntry>(context, table_info->catalog, table_info->schema,
+                                                 dynamic_cast<CreateTableInfo &>(*table_info).table)) {
 }
 
 idx_t LogicalInsert::EstimateCardinality(ClientContext &context) {

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

@@ -0,0 +1,9 @@
+#include "duckdb/planner/operator/logical_materialized_cte.hpp"
+
+namespace duckdb {
+
+vector<idx_t> LogicalMaterializedCTE::GetTableIndex() const {
+	return vector<idx_t> {table_index};
+}
+
+} // namespace duckdb

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

@@ -1,20 +1,44 @@
 #include "duckdb/planner/operator/logical_order.hpp"
 
-#include "duckdb/common/field_writer.hpp"
-
 namespace duckdb {
 
-void LogicalOrder::Serialize(FieldWriter &writer) const {
-	writer.WriteRegularSerializableList(orders);
-	writer.WriteList<idx_t>(projections);
+LogicalOrder::LogicalOrder(vector<BoundOrderByNode> orders)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_ORDER_BY), orders(std::move(orders)) {
+}
+
+vector<ColumnBinding> LogicalOrder::GetColumnBindings() {
+	auto child_bindings = children[0]->GetColumnBindings();
+	if (projections.empty()) {
+		return child_bindings;
+	}
+
+	vector<ColumnBinding> result;
+	for (auto &col_idx : projections) {
+		result.push_back(child_bindings[col_idx]);
+	}
+	return result;
+}
+
+string LogicalOrder::ParamsToString() const {
+	string result = "ORDERS:\n";
+	for (idx_t i = 0; i < orders.size(); i++) {
+		if (i > 0) {
+			result += "\n";
+		}
+		result += orders[i].expression->GetName();
+	}
+	return result;
 }
 
-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);
+void LogicalOrder::ResolveTypes() {
+	const auto child_types = children[0]->types;
+	if (projections.empty()) {
+		types = child_types;
+	} else {
+		for (auto &col_idx : projections) {
+			types.push_back(child_types[col_idx]);
+		}
+	}
 }
 
 } // namespace duckdb

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

@@ -4,6 +4,9 @@
 
 namespace duckdb {
 
+LogicalPivot::LogicalPivot() : LogicalOperator(LogicalOperatorType::LOGICAL_PIVOT) {
+}
+
 LogicalPivot::LogicalPivot(idx_t pivot_idx, unique_ptr<LogicalOperator> plan, BoundPivotInfo info_p)
     : LogicalOperator(LogicalOperatorType::LOGICAL_PIVOT), pivot_index(pivot_idx), bound_pivot(std::move(info_p)) {
 	D_ASSERT(plan);
@@ -18,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

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

@@ -2,14 +2,6 @@
 
 namespace duckdb {
 
-void LogicalPragma::Serialize(FieldWriter &writer) const {
-	throw NotImplementedException(LogicalOperatorToString(type));
-}
-
-unique_ptr<LogicalOperator> LogicalPragma::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	throw NotImplementedException(LogicalOperatorToString(state.type));
-}
-
 idx_t LogicalPragma::EstimateCardinality(ClientContext &context) {
 	return 1;
 }

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

@@ -2,14 +2,6 @@
 
 namespace duckdb {
 
-void LogicalPrepare::Serialize(FieldWriter &writer) const {
-	throw NotImplementedException(LogicalOperatorToString(type));
-}
-
-unique_ptr<LogicalOperator> LogicalPrepare::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	throw NotImplementedException(LogicalOperatorToString(state.type));
-}
-
 idx_t LogicalPrepare::EstimateCardinality(ClientContext &context) {
 	return 1;
 }

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

@@ -1,6 +1,5 @@
 #include "duckdb/planner/operator/logical_projection.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/main/config.hpp"
 
 namespace duckdb {
@@ -19,17 +18,6 @@ void LogicalProjection::ResolveTypes() {
 	}
 }
 
-void LogicalProjection::Serialize(FieldWriter &writer) const {
-	writer.WriteField(table_index);
-	writer.WriteSerializableList<Expression>(expressions);
-}
-
-unique_ptr<LogicalOperator> LogicalProjection::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto table_index = reader.ReadRequired<idx_t>();
-	auto expressions = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-	return make_uniq<LogicalProjection>(table_index, std::move(expressions));
-}
-
 vector<idx_t> LogicalProjection::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }

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

@@ -1,24 +1,9 @@
 #include "duckdb/planner/operator/logical_recursive_cte.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
-void LogicalRecursiveCTE::Serialize(FieldWriter &writer) const {
-	writer.WriteField(table_index);
-	writer.WriteField(column_count);
-	writer.WriteField(union_all);
-}
-
-unique_ptr<LogicalOperator> LogicalRecursiveCTE::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto table_index = reader.ReadRequired<idx_t>();
-	auto column_count = reader.ReadRequired<idx_t>();
-	auto union_all = reader.ReadRequired<bool>();
-	// TODO(stephwang): review if unique_ptr<LogicalOperator> plan is needed
-	return unique_ptr<LogicalRecursiveCTE>(new LogicalRecursiveCTE(table_index, column_count, union_all));
-}
-
 vector<idx_t> LogicalRecursiveCTE::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }

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

@@ -1,19 +1,7 @@
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/planner/operator/logical_reset.hpp"
 
 namespace duckdb {
 
-void LogicalReset::Serialize(FieldWriter &writer) const {
-	writer.WriteString(name);
-	writer.WriteField(scope);
-}
-
-unique_ptr<LogicalOperator> LogicalReset::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto name = reader.ReadRequired<std::string>();
-	auto scope = reader.ReadRequired<SetScope>();
-	return make_uniq<LogicalReset>(name, scope);
-}
-
 idx_t LogicalReset::EstimateCardinality(ClientContext &context) {
 	return 1;
 }

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

@@ -1,8 +1,10 @@
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/planner/operator/logical_sample.hpp"
 
 namespace duckdb {
 
+LogicalSample::LogicalSample() : LogicalOperator(LogicalOperatorType::LOGICAL_SAMPLE) {
+}
+
 LogicalSample::LogicalSample(unique_ptr<SampleOptions> sample_options_p, unique_ptr<LogicalOperator> child)
     : LogicalOperator(LogicalOperatorType::LOGICAL_SAMPLE), sample_options(std::move(sample_options_p)) {
 	children.push_back(std::move(child));
@@ -34,14 +36,4 @@ void LogicalSample::ResolveTypes() {
 	types = children[0]->types;
 }
 
-void LogicalSample::Serialize(FieldWriter &writer) const {
-	sample_options->Serialize(writer.GetSerializer());
-}
-
-unique_ptr<LogicalOperator> LogicalSample::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto sample_options = SampleOptions::Deserialize(reader.GetSource());
-	// TODO(stephwang): review how to pass child LogicalOperator
-	auto result = make_uniq<LogicalSample>(std::move(sample_options), nullptr);
-	return std::move(result);
-}
 } // namespace duckdb

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

@@ -1,21 +1,7 @@
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/planner/operator/logical_set.hpp"
 
 namespace duckdb {
 
-void LogicalSet::Serialize(FieldWriter &writer) const {
-	writer.WriteString(name);
-	value.Serialize(writer.GetSerializer());
-	writer.WriteField(scope);
-}
-
-unique_ptr<LogicalOperator> LogicalSet::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto name = reader.ReadRequired<std::string>();
-	auto value = Value::Deserialize(reader.GetSource());
-	auto scope = reader.ReadRequired<SetScope>();
-	return make_uniq<LogicalSet>(name, value, scope);
-}
-
 idx_t LogicalSet::EstimateCardinality(ClientContext &context) {
 	return 1;
 }

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

@@ -1,22 +1,9 @@
 #include "duckdb/planner/operator/logical_set_operation.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
-void LogicalSetOperation::Serialize(FieldWriter &writer) const {
-	writer.WriteField(table_index);
-	writer.WriteField(column_count);
-}
-
-unique_ptr<LogicalOperator> LogicalSetOperation::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto table_index = reader.ReadRequired<idx_t>();
-	auto column_count = reader.ReadRequired<idx_t>();
-	// TODO(stephwang): review if unique_ptr<LogicalOperator> plan is needed
-	return unique_ptr<LogicalSetOperation>(new LogicalSetOperation(table_index, column_count, state.type));
-}
-
 vector<idx_t> LogicalSetOperation::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }

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

@@ -9,66 +9,6 @@
 
 namespace duckdb {
 
-void LogicalSimple::Serialize(FieldWriter &writer) const {
-	writer.WriteField<LogicalOperatorType>(type);
-	switch (type) {
-	case LogicalOperatorType::LOGICAL_ALTER:
-		info->Cast<AlterInfo>().Serialize(writer.GetSerializer());
-		break;
-	case LogicalOperatorType::LOGICAL_DROP:
-		info->Cast<DropInfo>().Serialize(writer.GetSerializer());
-		break;
-	case LogicalOperatorType::LOGICAL_LOAD:
-		info->Cast<LoadInfo>().Serialize(writer.GetSerializer());
-		break;
-	case LogicalOperatorType::LOGICAL_VACUUM:
-		info->Cast<VacuumInfo>().Serialize(writer.GetSerializer());
-		break;
-	case LogicalOperatorType::LOGICAL_ATTACH:
-		info->Cast<AttachInfo>().Serialize(writer.GetSerializer());
-		break;
-	case LogicalOperatorType::LOGICAL_DETACH:
-		info->Cast<DetachInfo>().Serialize(writer.GetSerializer());
-		break;
-	case LogicalOperatorType::LOGICAL_TRANSACTION:
-		info->Cast<TransactionInfo>().Serialize(writer.GetSerializer());
-		break;
-	default:
-		throw InternalException(LogicalOperatorToString(type));
-	}
-}
-
-unique_ptr<LogicalOperator> LogicalSimple::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto type = reader.ReadRequired<LogicalOperatorType>();
-	unique_ptr<ParseInfo> parse_info;
-	switch (type) {
-	case LogicalOperatorType::LOGICAL_ALTER:
-		parse_info = AlterInfo::Deserialize(reader.GetSource());
-		break;
-	case LogicalOperatorType::LOGICAL_DROP:
-		parse_info = DropInfo::Deserialize(reader.GetSource());
-		break;
-	case LogicalOperatorType::LOGICAL_LOAD:
-		parse_info = LoadInfo::Deserialize(reader.GetSource());
-		break;
-	case LogicalOperatorType::LOGICAL_VACUUM:
-		parse_info = VacuumInfo::Deserialize(reader.GetSource());
-		break;
-	case LogicalOperatorType::LOGICAL_ATTACH:
-		parse_info = AttachInfo::Deserialize(reader.GetSource());
-		break;
-	case LogicalOperatorType::LOGICAL_DETACH:
-		parse_info = DetachInfo::Deserialize(reader.GetSource());
-		break;
-	case LogicalOperatorType::LOGICAL_TRANSACTION:
-		parse_info = TransactionInfo::Deserialize(reader.GetSource());
-		break;
-	default:
-		throw InternalException(LogicalOperatorToString(state.type));
-	}
-	return make_uniq<LogicalSimple>(type, std::move(parse_info));
-}
-
 idx_t LogicalSimple::EstimateCardinality(ClientContext &context) {
 	return 1;
 }

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

@@ -1,21 +1,7 @@
 #include "duckdb/planner/operator/logical_top_n.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
-void LogicalTopN::Serialize(FieldWriter &writer) const {
-	writer.WriteRegularSerializableList(orders);
-	writer.WriteField(offset);
-	writer.WriteField(limit);
-}
-
-unique_ptr<LogicalOperator> LogicalTopN::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto orders = reader.ReadRequiredSerializableList<BoundOrderByNode, BoundOrderByNode>(state.gstate);
-	auto offset = reader.ReadRequired<idx_t>();
-	auto limit = reader.ReadRequired<idx_t>();
-	return make_uniq<LogicalTopN>(std::move(orders), limit, offset);
-}
-
 idx_t LogicalTopN::EstimateCardinality(ClientContext &context) {
 	auto child_cardinality = LogicalOperator::EstimateCardinality(context);
 	if (limit >= 0 && child_cardinality < idx_t(limit)) {

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

@@ -1,6 +1,5 @@
 #include "duckdb/planner/operator/logical_unnest.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/main/config.hpp"
 
 namespace duckdb {
@@ -20,19 +19,6 @@ void LogicalUnnest::ResolveTypes() {
 	}
 }
 
-void LogicalUnnest::Serialize(FieldWriter &writer) const {
-	writer.WriteField(unnest_index);
-	writer.WriteSerializableList<Expression>(expressions);
-}
-
-unique_ptr<LogicalOperator> LogicalUnnest::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto unnest_index = reader.ReadRequired<idx_t>();
-	auto expressions = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-	auto result = make_uniq<LogicalUnnest>(unnest_index);
-	result->expressions = std::move(expressions);
-	return std::move(result);
-}
-
 vector<idx_t> LogicalUnnest::GetTableIndex() const {
 	return vector<idx_t> {unnest_index};
 }

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

@@ -1,5 +1,4 @@
 #include "duckdb/planner/operator/logical_update.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/parser/parsed_data/create_table_info.hpp"
 #include "duckdb/main/config.hpp"
@@ -10,30 +9,10 @@ LogicalUpdate::LogicalUpdate(TableCatalogEntry &table)
     : LogicalOperator(LogicalOperatorType::LOGICAL_UPDATE), table(table), table_index(0), return_chunk(false) {
 }
 
-void LogicalUpdate::Serialize(FieldWriter &writer) const {
-	table.Serialize(writer.GetSerializer());
-	writer.WriteField(table_index);
-	writer.WriteField(return_chunk);
-	writer.WriteIndexList<PhysicalIndex>(columns);
-	writer.WriteSerializableList(bound_defaults);
-	writer.WriteField(update_is_del_and_insert);
-	writer.WriteSerializableList(this->expressions);
-}
-
-unique_ptr<LogicalOperator> LogicalUpdate::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto &context = state.gstate.context;
-	auto info = TableCatalogEntry::Deserialize(reader.GetSource(), context);
-	auto &catalog = Catalog::GetCatalog(context, info->catalog);
-
-	auto &table_catalog_entry = catalog.GetEntry<TableCatalogEntry>(context, info->schema, info->table);
-	auto result = make_uniq<LogicalUpdate>(table_catalog_entry);
-	result->table_index = reader.ReadRequired<idx_t>();
-	result->return_chunk = reader.ReadRequired<bool>();
-	result->columns = reader.ReadRequiredIndexList<PhysicalIndex>();
-	result->bound_defaults = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-	result->update_is_del_and_insert = reader.ReadRequired<bool>();
-	result->expressions = reader.ReadRequiredSerializableList<duckdb::Expression>(state.gstate);
-	return std::move(result);
+LogicalUpdate::LogicalUpdate(ClientContext &context, const unique_ptr<CreateInfo> &table_info)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_UPDATE),
+      table(Catalog::GetEntry<TableCatalogEntry>(context, table_info->catalog, table_info->schema,
+                                                 dynamic_cast<CreateTableInfo &>(*table_info).table)) {
 }
 
 idx_t LogicalUpdate::EstimateCardinality(ClientContext &context) {

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

@@ -1,6 +1,5 @@
 #include "duckdb/planner/operator/logical_window.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/main/config.hpp"
 
 namespace duckdb {
@@ -20,18 +19,6 @@ void LogicalWindow::ResolveTypes() {
 	}
 }
 
-void LogicalWindow::Serialize(FieldWriter &writer) const {
-	writer.WriteField(window_index);
-	writer.WriteSerializableList<Expression>(expressions);
-}
-
-unique_ptr<LogicalOperator> LogicalWindow::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto window_index = reader.ReadRequired<idx_t>();
-	auto result = make_uniq<LogicalWindow>(window_index);
-	result->expressions = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-	return std::move(result);
-}
-
 vector<idx_t> LogicalWindow::GetTableIndex() const {
 	return vector<idx_t> {window_index};
 }