duckdb 0.8.2-dev77.0 → 0.9.0

package/src/duckdb/src/include/duckdb/planner/operator/logical_dependent_join.hpp

@@ -0,0 +1,42 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/operator/logical_dependent_join.hpp
+//
+// logical_dependent_join represents a logical operator for lateral joins that
+// is planned but not yet flattened
+//
+// This construct only exists during planning and should not exist in the plan
+// once flattening is complete. Although the same information can be kept in the
+// join itself, creating a new construct makes the code cleaner and easier to
+// understand.
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/planner/operator/logical_comparison_join.hpp"
+
+namespace duckdb {
+
+class LogicalDependentJoin : public LogicalComparisonJoin {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_DEPENDENT_JOIN;
+
+public:
+	explicit LogicalDependentJoin(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right,
+	                              vector<CorrelatedColumnInfo> correlated_columns, JoinType type,
+	                              unique_ptr<Expression> condition);
+
+	//! The conditions of the join
+	unique_ptr<Expression> join_condition;
+	//! The list of columns that have correlations with the right
+	vector<CorrelatedColumnInfo> correlated_columns;
+
+public:
+	static unique_ptr<LogicalOperator> Create(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right,
+	                                          vector<CorrelatedColumnInfo> correlated_columns, JoinType type,
+	                                          unique_ptr<Expression> condition);
+};
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_distinct.hpp

@@ -19,13 +19,8 @@ public:
 	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_DISTINCT;
 
 public:
-	explicit LogicalDistinct(DistinctType distinct_type)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_DISTINCT), distinct_type(distinct_type) {
-	}
-	explicit LogicalDistinct(vector<unique_ptr<Expression>> targets, DistinctType distinct_type)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_DISTINCT), distinct_type(distinct_type),
-	      distinct_targets(std::move(targets)) {
-	}
+	explicit LogicalDistinct(DistinctType distinct_type);
+	explicit LogicalDistinct(vector<unique_ptr<Expression>> targets, DistinctType distinct_type);
 
 	//! Whether or not this is a DISTINCT or DISTINCT ON
 	DistinctType distinct_type;
@@ -40,12 +35,11 @@ public:
 	vector<ColumnBinding> GetColumnBindings() override {
 		return children[0]->GetColumnBindings();
 	}
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
 
 protected:
-	void ResolveTypes() override {
-		types = children[0]->types;
-	}
+	void ResolveTypes() override;
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_dummy_scan.hpp

@@ -32,8 +32,8 @@ public:
 	idx_t EstimateCardinality(ClientContext &context) override {
 		return 1;
 	}
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
 	vector<idx_t> GetTableIndex() const override;
 	string GetName() const override;
 

package/src/duckdb/src/include/duckdb/planner/operator/logical_empty_result.hpp

@@ -32,8 +32,8 @@ public:
 	vector<ColumnBinding> GetColumnBindings() override {
 		return bindings;
 	}
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
 	idx_t EstimateCardinality(ClientContext &context) override {
 		return 0;
 	}

package/src/duckdb/src/include/duckdb/planner/operator/logical_execute.hpp

@@ -27,8 +27,6 @@ public:
 	shared_ptr<PreparedStatementData> prepared;
 
 public:
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 	//! Skips the serialization check in VerifyPlan
 	bool SupportSerialization() const override {
 		return false;

package/src/duckdb/src/include/duckdb/planner/operator/logical_explain.hpp

@@ -32,8 +32,9 @@ public:
 	string logical_plan_opt;
 
 public:
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
+
 	idx_t EstimateCardinality(ClientContext &context) override {
 		return 3;
 	}

package/src/duckdb/src/include/duckdb/planner/operator/logical_export.hpp

@@ -29,9 +29,6 @@ public:
 	BoundExportData exported_tables;
 
 public:
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
-
 protected:
 	void ResolveTypes() override {
 		types.emplace_back(LogicalType::BOOLEAN);

package/src/duckdb/src/include/duckdb/planner/operator/logical_expression_get.hpp

@@ -35,8 +35,9 @@ public:
 	vector<ColumnBinding> GetColumnBindings() override {
 		return GenerateColumnBindings(table_index, expr_types.size());
 	}
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
 	idx_t EstimateCardinality(ClientContext &context) override {
 		return expressions.size();
 	}

package/src/duckdb/src/include/duckdb/planner/operator/logical_extension_operator.hpp

@@ -13,6 +13,8 @@
 
 namespace duckdb {
 
+class ColumnBindingResolver;
+
 struct LogicalExtensionOperator : public LogicalOperator {
 public:
 	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR;
@@ -24,8 +26,12 @@ public:
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR, std::move(expressions)) {
 	}
 
-	static unique_ptr<LogicalExtensionOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	virtual void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
 
 	virtual unique_ptr<PhysicalOperator> CreatePlan(ClientContext &context, PhysicalPlanGenerator &generator) = 0;
+
+	virtual void ResolveColumnBindings(ColumnBindingResolver &res, vector<ColumnBinding> &bindings);
+	virtual string GetExtensionName() const;
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_filter.hpp

@@ -25,8 +25,9 @@ public:
 
 public:
 	vector<ColumnBinding> GetColumnBindings() override;
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
 
 	bool SplitPredicates() {
 		return SplitPredicates(expressions);

package/src/duckdb/src/include/duckdb/planner/operator/logical_get.hpp

@@ -11,6 +11,7 @@
 #include "duckdb/function/table_function.hpp"
 #include "duckdb/planner/logical_operator.hpp"
 #include "duckdb/planner/table_filter.hpp"
+#include "duckdb/common/extra_operator_info.hpp"
 
 namespace duckdb {
 
@@ -49,6 +50,9 @@ public:
 	vector<string> input_table_names;
 	//! For a table-in-out function, the set of projected input columns
 	vector<column_t> projected_input;
+	//! Currently stores File Filters (as strings) applied by hive partitioning/complex filter pushdown
+	//! Stored so the can be included in explain output
+	ExtraOperatorInfo extra_info;
 
 	string GetName() const override;
 	string ParamsToString() const override;
@@ -59,15 +63,19 @@ public:
 	vector<ColumnBinding> GetColumnBindings() override;
 	idx_t EstimateCardinality(ClientContext &context) override;
 
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 	vector<idx_t> GetTableIndex() const override;
 	//! Skips the serialization check in VerifyPlan
 	bool SupportSerialization() const override {
 		return function.verify_serialization;
-	};
+	}
+
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
 
 protected:
 	void ResolveTypes() override;
+
+private:
+	LogicalGet();
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_insert.hpp

@@ -60,8 +60,8 @@ public:
 	vector<column_t> source_columns;
 
 public:
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
 
 protected:
 	vector<ColumnBinding> GetColumnBindings() override;
@@ -70,5 +70,8 @@ protected:
 	idx_t EstimateCardinality(ClientContext &context) override;
 	vector<idx_t> GetTableIndex() const override;
 	string GetName() const override;
+
+private:
+	LogicalInsert(ClientContext &context, const unique_ptr<CreateInfo> table_info);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_join.hpp

@@ -30,7 +30,7 @@ public:
 	//! The type of the join (INNER, OUTER, etc...)
 	JoinType join_type;
 	//! Table index used to refer to the MARK column (in case of a MARK join)
-	idx_t mark_index;
+	idx_t mark_index {};
 	//! The columns of the LHS that are output by the join
 	vector<idx_t> left_projection_map;
 	//! The columns of the RHS that are output by the join
@@ -40,8 +40,6 @@ public:
 
 public:
 	vector<ColumnBinding> GetColumnBindings() override;
-	void Serialize(FieldWriter &writer) const override;
-	static void Deserialize(LogicalJoin &join, LogicalDeserializationState &state, FieldReader &reader);
 
 protected:
 	void ResolveTypes() override;

package/src/duckdb/src/include/duckdb/planner/operator/logical_limit.hpp

@@ -32,8 +32,8 @@ public:
 	vector<ColumnBinding> GetColumnBindings() override;
 	idx_t EstimateCardinality(ClientContext &context) override;
 
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
 
 protected:
 	void ResolveTypes() override;

package/src/duckdb/src/include/duckdb/planner/operator/logical_limit_percent.hpp

@@ -37,8 +37,8 @@ public:
 		return children[0]->GetColumnBindings();
 	}
 
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
 	idx_t EstimateCardinality(ClientContext &context) override;
 
 protected:

package/src/duckdb/src/include/duckdb/planner/operator/logical_materialized_cte.hpp

@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/operator/logical_materialized_cte.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/planner/logical_operator.hpp"
+
+namespace duckdb {
+
+class LogicalMaterializedCTE : public LogicalOperator {
+	explicit LogicalMaterializedCTE() : LogicalOperator(LogicalOperatorType::LOGICAL_MATERIALIZED_CTE) {
+	}
+
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_MATERIALIZED_CTE;
+
+public:
+	LogicalMaterializedCTE(string ctename, idx_t table_index, idx_t column_count, unique_ptr<LogicalOperator> cte,
+	                       unique_ptr<LogicalOperator> child)
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_MATERIALIZED_CTE), table_index(table_index),
+	      column_count(column_count), ctename(ctename) {
+		children.push_back(std::move(cte));
+		children.push_back(std::move(child));
+	}
+
+	idx_t table_index;
+	idx_t column_count;
+	string ctename;
+
+public:
+	vector<ColumnBinding> GetColumnBindings() override {
+		return children[1]->GetColumnBindings();
+	}
+
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
+
+	vector<idx_t> GetTableIndex() const override;
+
+protected:
+	void ResolveTypes() override {
+		types = children[1]->types;
+	}
+};
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_order.hpp

@@ -21,51 +21,20 @@ public:
 	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_ORDER_BY;
 
 public:
-	explicit LogicalOrder(vector<BoundOrderByNode> orders)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_ORDER_BY), orders(std::move(orders)) {
-	}
+	explicit LogicalOrder(vector<BoundOrderByNode> orders);
 
 	vector<BoundOrderByNode> orders;
 	vector<idx_t> projections;
 
 public:
-	vector<ColumnBinding> GetColumnBindings() override {
-		auto child_bindings = children[0]->GetColumnBindings();
-		if (projections.empty()) {
-			return child_bindings;
-		}
+	vector<ColumnBinding> GetColumnBindings() override;
 
-		vector<ColumnBinding> result;
-		for (auto &col_idx : projections) {
-			result.push_back(child_bindings[col_idx]);
-		}
-		return result;
-	}
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
 
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
-
-	string ParamsToString() const override {
-		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;
-	}
+	string ParamsToString() const override;
 
 protected:
-	void ResolveTypes() override {
-		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]);
-			}
-		}
-	}
+	void ResolveTypes() override;
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_pivot.hpp

@@ -29,12 +29,16 @@ public:
 
 public:
 	vector<ColumnBinding> GetColumnBindings() override;
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
 	vector<idx_t> GetTableIndex() const override;
 	string GetName() const override;
 
 protected:
 	void ResolveTypes() override;
+
+private:
+	LogicalPivot();
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_positional_join.hpp

@@ -25,7 +25,7 @@ public:
 public:
 	static unique_ptr<LogicalOperator> Create(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right);
 
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_pragma.hpp

@@ -31,8 +31,6 @@ public:
 	PragmaInfo info;
 
 public:
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 	idx_t EstimateCardinality(ClientContext &context) override;
 	//! Skips the serialization check in VerifyPlan
 	bool SupportSerialization() const override {

package/src/duckdb/src/include/duckdb/planner/operator/logical_prepare.hpp

@@ -33,8 +33,6 @@ public:
 	shared_ptr<PreparedStatementData> prepared;
 
 public:
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 	idx_t EstimateCardinality(ClientContext &context) override;
 	//! Skips the serialization check in VerifyPlan
 	bool SupportSerialization() const override {

package/src/duckdb/src/include/duckdb/planner/operator/logical_projection.hpp

@@ -24,8 +24,9 @@ public:
 
 public:
 	vector<ColumnBinding> GetColumnBindings() override;
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
+
 	vector<idx_t> GetTableIndex() const override;
 	string GetName() const override;
 

package/src/duckdb/src/include/duckdb/planner/operator/logical_recursive_cte.hpp

@@ -13,24 +13,23 @@
 namespace duckdb {
 
 class LogicalRecursiveCTE : public LogicalOperator {
-	LogicalRecursiveCTE(idx_t table_index, idx_t column_count, bool union_all)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_RECURSIVE_CTE), union_all(union_all), table_index(table_index),
-	      column_count(column_count) {
+	LogicalRecursiveCTE() : LogicalOperator(LogicalOperatorType::LOGICAL_RECURSIVE_CTE) {
 	}
 
 public:
 	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_RECURSIVE_CTE;
 
 public:
-	LogicalRecursiveCTE(idx_t table_index, idx_t column_count, bool union_all, unique_ptr<LogicalOperator> top,
-	                    unique_ptr<LogicalOperator> bottom)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_RECURSIVE_CTE), union_all(union_all), table_index(table_index),
-	      column_count(column_count) {
+	LogicalRecursiveCTE(string ctename, idx_t table_index, idx_t column_count, bool union_all,
+	                    unique_ptr<LogicalOperator> top, unique_ptr<LogicalOperator> bottom)
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_RECURSIVE_CTE), union_all(union_all), ctename(ctename),
+	      table_index(table_index), column_count(column_count) {
 		children.push_back(std::move(top));
 		children.push_back(std::move(bottom));
 	}
 
 	bool union_all;
+	string ctename;
 	idx_t table_index;
 	idx_t column_count;
 
@@ -38,8 +37,10 @@ public:
 	vector<ColumnBinding> GetColumnBindings() override {
 		return GenerateColumnBindings(table_index, column_count);
 	}
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
+
 	vector<idx_t> GetTableIndex() const override;
 	string GetName() const override;
 

package/src/duckdb/src/include/duckdb/planner/operator/logical_reset.hpp

@@ -28,8 +28,9 @@ public:
 	SetScope scope;
 
 public:
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
+
 	idx_t EstimateCardinality(ClientContext &context) override;
 
 protected:

package/src/duckdb/src/include/duckdb/planner/operator/logical_sample.hpp

@@ -28,11 +28,14 @@ public:
 	vector<ColumnBinding> GetColumnBindings() override;
 	idx_t EstimateCardinality(ClientContext &context) override;
 
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
 
 protected:
 	void ResolveTypes() override;
+
+private:
+	LogicalSample();
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_set.hpp

@@ -29,8 +29,9 @@ public:
 	SetScope scope;
 
 public:
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
+
 	idx_t EstimateCardinality(ClientContext &context) override;
 
 protected:

package/src/duckdb/src/include/duckdb/planner/operator/logical_set_operation.hpp

@@ -38,8 +38,9 @@ public:
 		return GenerateColumnBindings(table_index, column_count);
 	}
 
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
+
 	vector<idx_t> GetTableIndex() const override;
 	string GetName() const override;
 

package/src/duckdb/src/include/duckdb/planner/operator/logical_show.hpp

@@ -27,8 +27,8 @@ public:
 	vector<string> aliases;
 
 public:
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
 
 protected:
 	void ResolveTypes() override {

package/src/duckdb/src/include/duckdb/planner/operator/logical_simple.hpp

@@ -26,8 +26,8 @@ public:
 	unique_ptr<ParseInfo> info;
 
 public:
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
 	idx_t EstimateCardinality(ClientContext &context) override;
 
 protected:

package/src/duckdb/src/include/duckdb/planner/operator/logical_top_n.hpp

@@ -33,8 +33,10 @@ public:
 	vector<ColumnBinding> GetColumnBindings() override {
 		return children[0]->GetColumnBindings();
 	}
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
+
 	idx_t EstimateCardinality(ClientContext &context) override;
 
 protected:

package/src/duckdb/src/include/duckdb/planner/operator/logical_unnest.hpp

@@ -26,8 +26,8 @@ public:
 
 public:
 	vector<ColumnBinding> GetColumnBindings() override;
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
 	vector<idx_t> GetTableIndex() const override;
 	string GetName() const override;
 

package/src/duckdb/src/include/duckdb/planner/operator/logical_update.hpp

@@ -31,13 +31,17 @@ public:
 	bool update_is_del_and_insert;
 
 public:
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
+
 	idx_t EstimateCardinality(ClientContext &context) override;
 	string GetName() const override;
 
 protected:
 	vector<ColumnBinding> GetColumnBindings() override;
 	void ResolveTypes() override;
+
+private:
+	LogicalUpdate(ClientContext &context, const unique_ptr<CreateInfo> &table_info);
 };
 } // namespace duckdb