duckdb 0.8.2-dev37.0 → 0.8.2-dev3989.0

package/src/duckdb/src/include/duckdb/planner/constraints/bound_unique_constraint.hpp

@@ -23,9 +23,9 @@ public:
 	    : BoundConstraint(ConstraintType::UNIQUE), keys(std::move(keys)), key_set(std::move(key_set)),
 	      is_primary_key(is_primary_key) {
 #ifdef DEBUG
-		D_ASSERT(keys.size() == key_set.size());
-		for (auto &key : keys) {
-			D_ASSERT(key_set.find(key) != key_set.end());
+		D_ASSERT(this->keys.size() == this->key_set.size());
+		for (auto &key : this->keys) {
+			D_ASSERT(this->key_set.find(key) != this->key_set.end());
 		}
 #endif
 	}

package/src/duckdb/src/include/duckdb/planner/expression/bound_aggregate_expression.hpp

@@ -57,5 +57,8 @@ public:
 	unique_ptr<Expression> Copy() override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<Expression> Deserialize(ExpressionDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<Expression> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression/bound_between_expression.hpp

@@ -35,6 +35,9 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<Expression> Deserialize(ExpressionDeserializationState &state, FieldReader &reader);
 
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<Expression> FormatDeserialize(FormatDeserializer &deserializer);
+
 public:
 	ExpressionType LowerComparisonType() {
 		return lower_inclusive ? ExpressionType::COMPARE_GREATERTHANOREQUALTO : ExpressionType::COMPARE_GREATERTHAN;
@@ -42,5 +45,8 @@ public:
 	ExpressionType UpperComparisonType() {
 		return upper_inclusive ? ExpressionType::COMPARE_LESSTHANOREQUALTO : ExpressionType::COMPARE_LESSTHAN;
 	}
+
+private:
+	BoundBetweenExpression();
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression/bound_case_expression.hpp

@@ -18,6 +18,9 @@ struct BoundCaseCheck {
 
 	void Serialize(Serializer &serializer) const;
 	static BoundCaseCheck Deserialize(Deserializer &source, PlanDeserializationState &state);
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static BoundCaseCheck FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class BoundCaseExpression : public Expression {
@@ -41,5 +44,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<Expression> Deserialize(ExpressionDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<Expression> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression/bound_cast_expression.hpp

@@ -52,5 +52,11 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<Expression> Deserialize(ExpressionDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<Expression> FormatDeserialize(FormatDeserializer &deserializer);
+
+private:
+	BoundCastExpression(ClientContext &context, unique_ptr<Expression> child, LogicalType target_type);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression/bound_columnref_expression.hpp

@@ -51,5 +51,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<Expression> Deserialize(ExpressionDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<Expression> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression/bound_comparison_expression.hpp

@@ -31,6 +31,9 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<Expression> Deserialize(ExpressionDeserializationState &state, FieldReader &reader);
 
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<Expression> FormatDeserialize(FormatDeserializer &deserializer);
+
 public:
 	static LogicalType BindComparison(LogicalType left_type, LogicalType right_type);
 };

package/src/duckdb/src/include/duckdb/planner/expression/bound_conjunction_expression.hpp

@@ -33,5 +33,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<Expression> Deserialize(ExpressionDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<Expression> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression/bound_constant_expression.hpp

@@ -32,5 +32,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<Expression> Deserialize(ExpressionDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<Expression> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression/bound_default_expression.hpp

@@ -39,5 +39,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<Expression> Deserialize(ExpressionDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<Expression> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression/bound_function_expression.hpp

@@ -46,5 +46,9 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<Expression> Deserialize(ExpressionDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<Expression> FormatDeserialize(FormatDeserializer &deserializer);
 };
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression/bound_lambda_expression.hpp

@@ -33,6 +33,8 @@ public:
 	unique_ptr<Expression> Copy() override;
 
 	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<Expression> Deserialize(ExpressionDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<Expression> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression/bound_lambdaref_expression.hpp

@@ -53,5 +53,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<Expression> Deserialize(ExpressionDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<Expression> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression/bound_operator_expression.hpp

@@ -30,5 +30,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<Expression> Deserialize(ExpressionDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<Expression> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression/bound_parameter_data.hpp

@@ -11,19 +11,32 @@
 #include "duckdb/common/types/value.hpp"
 #include "duckdb/planner/bound_parameter_map.hpp"
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/case_insensitive_map.hpp"
 
 namespace duckdb {
 
 struct BoundParameterData {
+public:
 	BoundParameterData() {
 	}
-	BoundParameterData(Value val) : value(std::move(val)), return_type(value.type()) {
+	explicit BoundParameterData(Value val) : value(std::move(val)), return_type(value.type()) {
 	}
 
+private:
 	Value value;
+
+public:
 	LogicalType return_type;
 
 public:
+	void SetValue(Value val) {
+		value = std::move(val);
+	}
+
+	const Value &GetValue() const {
+		return value;
+	}
+
 	void Serialize(Serializer &serializer) const {
 		FieldWriter writer(serializer);
 		value.Serialize(writer.GetSerializer());
@@ -39,20 +52,25 @@ public:
 		reader.Finalize();
 		return result;
 	}
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static shared_ptr<BoundParameterData> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 struct BoundParameterMap {
-	BoundParameterMap(vector<BoundParameterData> &parameter_data) : parameter_data(parameter_data) {
+	explicit BoundParameterMap(case_insensitive_map_t<BoundParameterData> &parameter_data)
+	    : parameter_data(parameter_data) {
 	}
 
 	bound_parameter_map_t parameters;
-	vector<BoundParameterData> &parameter_data;
+	case_insensitive_map_t<BoundParameterData> &parameter_data;
 
-	LogicalType GetReturnType(idx_t index) {
-		if (index >= parameter_data.size()) {
+	LogicalType GetReturnType(const string &identifier) {
+		auto it = parameter_data.find(identifier);
+		if (it == parameter_data.end()) {
 			return LogicalTypeId::UNKNOWN;
 		}
-		return parameter_data[index].return_type;
+		return it->second.return_type;
 	}
 };
 

package/src/duckdb/src/include/duckdb/planner/expression/bound_parameter_expression.hpp

@@ -18,9 +18,9 @@ public:
 	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_PARAMETER;
 
 public:
-	explicit BoundParameterExpression(idx_t parameter_nr);
+	explicit BoundParameterExpression(const string &identifier);
 
-	idx_t parameter_nr;
+	string identifier;
 	shared_ptr<BoundParameterData> parameter_data;
 
 public:
@@ -42,6 +42,13 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<Expression> Deserialize(ExpressionDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<Expression> FormatDeserialize(FormatDeserializer &deserializer);
+
+private:
+	BoundParameterExpression(bound_parameter_map_t &global_parameter_set, string identifier, LogicalType return_type,
+	                         shared_ptr<BoundParameterData> parameter_data);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression/bound_reference_expression.hpp

@@ -41,5 +41,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<Expression> Deserialize(ExpressionDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<Expression> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression/bound_unnest_expression.hpp

@@ -33,5 +33,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<Expression> Deserialize(ExpressionDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<Expression> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression/bound_window_expression.hpp

@@ -67,5 +67,8 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<Expression> Deserialize(ExpressionDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<Expression> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression/list.hpp

@@ -9,6 +9,7 @@
 #include "duckdb/planner/expression/bound_default_expression.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/planner/expression/bound_lambda_expression.hpp"
+#include "duckdb/planner/expression/bound_lambdaref_expression.hpp"
 #include "duckdb/planner/expression/bound_operator_expression.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
 #include "duckdb/planner/expression/bound_reference_expression.hpp"

package/src/duckdb/src/include/duckdb/planner/expression.hpp

@@ -64,6 +64,9 @@ public:
 	//! SerializationException]
 	static unique_ptr<Expression> Deserialize(Deserializer &source, PlanDeserializationState &state);
 
+	virtual void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<Expression> FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	//! Copy base Expression properties from another expression to this one,
 	//! used in Copy method

package/src/duckdb/src/include/duckdb/planner/expression_binder/lateral_binder.hpp

@@ -20,8 +20,6 @@ class LateralBinder : public ExpressionBinder {
 public:
 	LateralBinder(Binder &binder, ClientContext &context);
 
-	//! Extract the correlated lateral join columns and remove them from the targeted binder
-	vector<CorrelatedColumnInfo> ExtractCorrelatedColumns(Binder &binder);
 	bool HasCorrelatedColumns() const {
 		return !correlated_columns.empty();
 	}

package/src/duckdb/src/include/duckdb/planner/expression_binder.hpp

@@ -9,11 +9,12 @@
 #pragma once
 
 #include "duckdb/common/exception.hpp"
+#include "duckdb/common/stack_checker.hpp"
+#include "duckdb/common/unordered_map.hpp"
 #include "duckdb/parser/expression/bound_expression.hpp"
 #include "duckdb/parser/parsed_expression.hpp"
 #include "duckdb/parser/tokens.hpp"
 #include "duckdb/planner/expression.hpp"
-#include "duckdb/common/unordered_map.hpp"
 
 namespace duckdb {
 
@@ -51,6 +52,8 @@ struct BindResult {
 };
 
 class ExpressionBinder {
+	friend class StackChecker<ExpressionBinder>;
+
 public:
 	ExpressionBinder(Binder &binder, ClientContext &context, bool replace_binder = false);
 	virtual ~ExpressionBinder();
@@ -110,6 +113,15 @@ public:
 
 	void ReplaceMacroParametersRecursive(unique_ptr<ParsedExpression> &expr);
 
+private:
+	//! Maximum stack depth
+	static constexpr const idx_t MAXIMUM_STACK_DEPTH = 128;
+	//! Current stack depth
+	idx_t stack_depth = DConstants::INVALID_INDEX;
+
+	void InitializeStackCheck();
+	StackChecker<ExpressionBinder> StackCheck(const ParsedExpression &expr, idx_t extra_stack = 1);
+
 protected:
 	BindResult BindExpression(BetweenExpression &expr, idx_t depth);
 	BindResult BindExpression(CaseExpression &expr, idx_t depth);

package/src/duckdb/src/include/duckdb/planner/filter/conjunction_filter.hpp

@@ -45,6 +45,8 @@ public:
 	bool Equals(const TableFilter &other) const override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<TableFilter> Deserialize(FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableFilter> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class ConjunctionAndFilter : public ConjunctionFilter {
@@ -60,6 +62,8 @@ public:
 	bool Equals(const TableFilter &other) const override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<TableFilter> Deserialize(FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableFilter> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/filter/constant_filter.hpp

@@ -32,6 +32,8 @@ public:
 	bool Equals(const TableFilter &other) const override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<TableFilter> Deserialize(FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableFilter> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/filter/null_filter.hpp

@@ -24,6 +24,8 @@ public:
 	string ToString(const string &column_name) override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<TableFilter> Deserialize(FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableFilter> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class IsNotNullFilter : public TableFilter {
@@ -38,6 +40,8 @@ public:
 	string ToString(const string &column_name) override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<TableFilter> Deserialize(FieldReader &source);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableFilter> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/joinside.hpp

@@ -29,6 +29,9 @@ public:
 	//! Deserializes a blob back into a JoinCondition
 	static JoinCondition Deserialize(Deserializer &source, PlanDeserializationState &state);
 
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static JoinCondition FormatDeserialize(FormatDeserializer &deserializer);
+
 public:
 	unique_ptr<Expression> left;
 	unique_ptr<Expression> right;

package/src/duckdb/src/include/duckdb/planner/logical_operator.hpp

@@ -49,8 +49,6 @@ public:
 	idx_t estimated_cardinality;
 	bool has_estimated_cardinality;
 
-	unique_ptr<EstimatedProperties> estimated_props;
-
 public:
 	virtual vector<ColumnBinding> GetColumnBindings();
 	static vector<ColumnBinding> GenerateColumnBindings(idx_t table_idx, idx_t column_count);
@@ -77,6 +75,9 @@ public:
 
 	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer, PlanDeserializationState &state);
 
+	virtual void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 	virtual unique_ptr<LogicalOperator> Copy(ClientContext &context) const;
 
 	virtual bool RequireOptimizer() const {

package/src/duckdb/src/include/duckdb/planner/logical_tokens.hpp

@@ -14,7 +14,6 @@ class LogicalOperator;
 
 class LogicalAggregate;
 class LogicalAnyJoin;
-class LogicalAsOfJoin;
 class LogicalColumnDataGet;
 class LogicalComparisonJoin;
 class LogicalCopyToFile;
@@ -26,7 +25,6 @@ class LogicalCrossProduct;
 class LogicalCTERef;
 class LogicalDelete;
 class LogicalDelimGet;
-class LogicalDelimJoin;
 class LogicalDistinct;
 class LogicalDummyScan;
 class LogicalEmptyResult;
@@ -46,6 +44,7 @@ class LogicalPragma;
 class LogicalPrepare;
 class LogicalProjection;
 class LogicalRecursiveCTE;
+class LogicalMaterializedCTE;
 class LogicalSetOperation;
 class LogicalSample;
 class LogicalShow;

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

@@ -1,6 +1,5 @@
 #include "duckdb/planner/operator/logical_aggregate.hpp"
 #include "duckdb/planner/operator/logical_any_join.hpp"
-#include "duckdb/planner/operator/logical_asof_join.hpp"
 #include "duckdb/planner/operator/logical_column_data_get.hpp"
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
 #include "duckdb/planner/operator/logical_copy_to_file.hpp"
@@ -11,7 +10,6 @@
 #include "duckdb/planner/operator/logical_cteref.hpp"
 #include "duckdb/planner/operator/logical_delete.hpp"
 #include "duckdb/planner/operator/logical_delim_get.hpp"
-#include "duckdb/planner/operator/logical_delim_join.hpp"
 #include "duckdb/planner/operator/logical_distinct.hpp"
 #include "duckdb/planner/operator/logical_dummy_scan.hpp"
 #include "duckdb/planner/operator/logical_empty_result.hpp"
@@ -19,12 +17,14 @@
 #include "duckdb/planner/operator/logical_explain.hpp"
 #include "duckdb/planner/operator/logical_export.hpp"
 #include "duckdb/planner/operator/logical_expression_get.hpp"
+#include "duckdb/planner/operator/logical_extension_operator.hpp"
 #include "duckdb/planner/operator/logical_filter.hpp"
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/planner/operator/logical_insert.hpp"
 #include "duckdb/planner/operator/logical_join.hpp"
 #include "duckdb/planner/operator/logical_limit.hpp"
 #include "duckdb/planner/operator/logical_limit_percent.hpp"
+#include "duckdb/planner/operator/logical_materialized_cte.hpp"
 #include "duckdb/planner/operator/logical_order.hpp"
 #include "duckdb/planner/operator/logical_pivot.hpp"
 #include "duckdb/planner/operator/logical_positional_join.hpp"
@@ -32,9 +32,9 @@
 #include "duckdb/planner/operator/logical_prepare.hpp"
 #include "duckdb/planner/operator/logical_projection.hpp"
 #include "duckdb/planner/operator/logical_recursive_cte.hpp"
+#include "duckdb/planner/operator/logical_reset.hpp"
 #include "duckdb/planner/operator/logical_sample.hpp"
 #include "duckdb/planner/operator/logical_set.hpp"
-#include "duckdb/planner/operator/logical_reset.hpp"
 #include "duckdb/planner/operator/logical_set_operation.hpp"
 #include "duckdb/planner/operator/logical_show.hpp"
 #include "duckdb/planner/operator/logical_simple.hpp"

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

@@ -45,6 +45,9 @@ public:
 	vector<ColumnBinding> GetColumnBindings() override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
 	idx_t EstimateCardinality(ClientContext &context) override;
 	vector<idx_t> GetTableIndex() const override;
 	string GetName() const override;

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

@@ -28,6 +28,9 @@ public:
 	string ParamsToString() const override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

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

@@ -33,6 +33,10 @@ public:
 
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 	vector<idx_t> GetTableIndex() const override;
 	string GetName() const override;
 

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

@@ -27,8 +27,10 @@ public:
 
 	//! The conditions of the join
 	vector<JoinCondition> conditions;
-	//! Used for duplicate-eliminated joins
-	vector<LogicalType> delim_types;
+	//! Used for duplicate-eliminated MARK joins
+	vector<LogicalType> mark_types;
+	//! The set of columns that will be duplicate eliminated from the LHS and pushed into the RHS
+	vector<unique_ptr<Expression>> duplicate_eliminated_columns;
 
 public:
 	string ParamsToString() const override;
@@ -37,26 +39,29 @@ public:
 	static void Deserialize(LogicalComparisonJoin &comparison_join, LogicalDeserializationState &state,
 	                        FieldReader &reader);
 
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 public:
-	static unique_ptr<LogicalOperator> CreateJoin(JoinType type, JoinRefType ref_type,
+	static unique_ptr<LogicalOperator> CreateJoin(ClientContext &context, JoinType type, JoinRefType ref_type,
 	                                              unique_ptr<LogicalOperator> left_child,
 	                                              unique_ptr<LogicalOperator> right_child,
 	                                              unique_ptr<Expression> condition);
-	static unique_ptr<LogicalOperator> CreateJoin(JoinType type, JoinRefType ref_type,
+	static unique_ptr<LogicalOperator> CreateJoin(ClientContext &context, JoinType type, JoinRefType ref_type,
 	                                              unique_ptr<LogicalOperator> left_child,
 	                                              unique_ptr<LogicalOperator> right_child,
 	                                              vector<JoinCondition> conditions,
 	                                              vector<unique_ptr<Expression>> arbitrary_expressions);
 
-	static void ExtractJoinConditions(JoinType type, unique_ptr<LogicalOperator> &left_child,
+	static void ExtractJoinConditions(ClientContext &context, JoinType type, unique_ptr<LogicalOperator> &left_child,
 	                                  unique_ptr<LogicalOperator> &right_child, unique_ptr<Expression> condition,
 	                                  vector<JoinCondition> &conditions,
 	                                  vector<unique_ptr<Expression>> &arbitrary_expressions);
-	static void ExtractJoinConditions(JoinType type, unique_ptr<LogicalOperator> &left_child,
+	static void ExtractJoinConditions(ClientContext &context, JoinType type, unique_ptr<LogicalOperator> &left_child,
 	                                  unique_ptr<LogicalOperator> &right_child,
 	                                  vector<unique_ptr<Expression>> &expressions, vector<JoinCondition> &conditions,
 	                                  vector<unique_ptr<Expression>> &arbitrary_expressions);
-	static void ExtractJoinConditions(JoinType type, unique_ptr<LogicalOperator> &left_child,
+	static void ExtractJoinConditions(ClientContext &context, JoinType type, unique_ptr<LogicalOperator> &left_child,
 	                                  unique_ptr<LogicalOperator> &right_child,
 	                                  const unordered_set<idx_t> &left_bindings,
 	                                  const unordered_set<idx_t> &right_bindings,

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

@@ -45,6 +45,8 @@ public:
 	bool SupportSerialization() const override {
 		return false;
 	}
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
 
 protected:
 	void ResolveTypes() override {

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

@@ -20,9 +20,7 @@ public:
 
 public:
 	LogicalCreate(LogicalOperatorType type, unique_ptr<CreateInfo> info,
-	              optional_ptr<SchemaCatalogEntry> schema = nullptr)
-	    : LogicalOperator(type), schema(schema), info(std::move(info)) {
-	}
+	              optional_ptr<SchemaCatalogEntry> schema = nullptr);
 
 	optional_ptr<SchemaCatalogEntry> schema;
 	unique_ptr<CreateInfo> info;
@@ -30,11 +28,16 @@ public:
 public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 	idx_t EstimateCardinality(ClientContext &context) override;
 
 protected:
-	void ResolveTypes() override {
-		types.emplace_back(LogicalType::BIGINT);
-	}
+	void ResolveTypes() override;
+
+private:
+	LogicalCreate(LogicalOperatorType type, ClientContext &context, unique_ptr<CreateInfo> info);
 };
 } // namespace duckdb