duckdb 0.8.2-dev1862.0 → 0.8.2-dev2044.0

package/src/duckdb/src/include/duckdb/parser/parsed_data/load_info.hpp

@@ -1,7 +1,7 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/parser/parsed_data/vacuum_info.hpp
+// duckdb/parser/parsed_data/load_info.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -13,10 +13,17 @@
 
 namespace duckdb {
 
-enum class LoadType { LOAD, INSTALL, FORCE_INSTALL };
+enum class LoadType : uint8_t { LOAD, INSTALL, FORCE_INSTALL };
 
 struct LoadInfo : public ParseInfo {
-	std::string filename;
+public:
+	static constexpr const ParseInfoType TYPE = ParseInfoType::LOAD_INFO;
+
+public:
+	LoadInfo() : ParseInfo(TYPE) {
+	}
+
+	string filename;
 	LoadType load_type;
 
 public:
@@ -42,6 +49,9 @@ public:
 		reader.Finalize();
 		return std::move(load_info);
 	}
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParseInfo> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parsed_data/parse_info.hpp

@@ -12,10 +12,29 @@
 
 namespace duckdb {
 
+enum class ParseInfoType : uint8_t {
+	ALTER_INFO,
+	ATTACH_INFO,
+	COPY_INFO,
+	CREATE_INFO,
+	DETACH_INFO,
+	DROP_INFO,
+	BOUND_EXPORT_DATA,
+	LOAD_INFO,
+	PRAGMA_INFO,
+	SHOW_SELECT_INFO,
+	TRANSACTION_INFO,
+	VACUUM_INFO
+};
+
 struct ParseInfo {
+	explicit ParseInfo(ParseInfoType info_type) : info_type(info_type) {
+	}
 	virtual ~ParseInfo() {
 	}
 
+	ParseInfoType info_type;
+
 public:
 	template <class TARGET>
 	TARGET &Cast() {
@@ -28,6 +47,9 @@ public:
 		D_ASSERT(dynamic_cast<const TARGET *>(this));
 		return reinterpret_cast<const TARGET &>(*this);
 	}
+
+	virtual void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<ParseInfo> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parsed_data/pragma_info.hpp

@@ -18,6 +18,13 @@ namespace duckdb {
 enum class PragmaType : uint8_t { PRAGMA_STATEMENT, PRAGMA_CALL };
 
 struct PragmaInfo : public ParseInfo {
+public:
+	static constexpr const ParseInfoType TYPE = ParseInfoType::PRAGMA_INFO;
+
+public:
+	PragmaInfo() : ParseInfo(TYPE) {
+	}
+
 	//! Name of the PRAGMA statement
 	string name;
 	//! Parameter list (if any)
@@ -33,6 +40,9 @@ public:
 		result->named_parameters = named_parameters;
 		return result;
 	}
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParseInfo> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parsed_data/show_select_info.hpp

@@ -14,6 +14,13 @@
 namespace duckdb {
 
 struct ShowSelectInfo : public ParseInfo {
+public:
+	static constexpr const ParseInfoType TYPE = ParseInfoType::SHOW_SELECT_INFO;
+
+public:
+	ShowSelectInfo() : ParseInfo(TYPE) {
+	}
+
 	//! Types of projected columns
 	vector<LogicalType> types;
 	//! The QueryNode of select query

package/src/duckdb/src/include/duckdb/parser/parsed_data/transaction_info.hpp

@@ -15,6 +15,10 @@ namespace duckdb {
 enum class TransactionType : uint8_t { INVALID, BEGIN_TRANSACTION, COMMIT, ROLLBACK };
 
 struct TransactionInfo : public ParseInfo {
+public:
+	static constexpr const ParseInfoType TYPE = ParseInfoType::TRANSACTION_INFO;
+
+public:
 	explicit TransactionInfo(TransactionType type);
 
 	//! The type of transaction statement
@@ -23,6 +27,12 @@ struct TransactionInfo : public ParseInfo {
 public:
 	void Serialize(Serializer &serializer) const;
 	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParseInfo> FormatDeserialize(FormatDeserializer &deserializer);
+
+private:
+	TransactionInfo();
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parsed_data/vacuum_info.hpp

@@ -15,6 +15,8 @@
 #include "duckdb/common/optional_ptr.hpp"
 
 namespace duckdb {
+class FormatSerializer;
+class FormatDeserializer;
 
 struct VacuumOptions {
 	VacuumOptions() : vacuum(false), analyze(false) {
@@ -22,9 +24,15 @@ struct VacuumOptions {
 
 	bool vacuum;
 	bool analyze;
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static VacuumOptions FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 struct VacuumInfo : public ParseInfo {
+public:
+	static constexpr const ParseInfoType TYPE = ParseInfoType::VACUUM_INFO;
+
 public:
 	explicit VacuumInfo(VacuumOptions options);
 
@@ -42,6 +50,8 @@ public:
 
 	void Serialize(Serializer &serializer) const;
 	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer);
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ParseInfo> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

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

@@ -21,14 +21,6 @@ public:
 	virtual ~BoundConstraint() {
 	}
 
-	void Serialize(Serializer &serializer) const {
-		serializer.Write(type);
-	}
-
-	static unique_ptr<BoundConstraint> Deserialize(Deserializer &source) {
-		return make_uniq<BoundConstraint>(source.Read<ConstraintType>());
-	}
-
 	ConstraintType type;
 
 public:

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

@@ -63,6 +63,9 @@ public:
 
 	void Serialize(Serializer &serializer) const;
 	static BoundOrderByNode Deserialize(Deserializer &source, PlanDeserializationState &state);
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static BoundOrderByNode FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class BoundLimitModifier : public BoundResultModifier {
@@ -98,6 +101,9 @@ public:
 
 	void Serialize(Serializer &serializer) const;
 	static unique_ptr<BoundOrderModifier> Deserialize(Deserializer &source, PlanDeserializationState &state);
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<BoundOrderModifier> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 enum class DistinctType : uint8_t { DISTINCT = 0, DISTINCT_ON = 1 };

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

@@ -14,6 +14,8 @@
 #include <functional>
 
 namespace duckdb {
+class FormatSerializer;
+class FormatDeserializer;
 
 struct ColumnBinding {
 	idx_t table_index;
@@ -36,6 +38,9 @@ struct ColumnBinding {
 	bool operator!=(const ColumnBinding &rhs) const {
 		return !(*this == rhs);
 	}
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static ColumnBinding 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_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

@@ -17,7 +17,7 @@ namespace duckdb {
 struct BoundParameterData {
 	BoundParameterData() {
 	}
-	BoundParameterData(Value val) : value(std::move(val)), return_type(value.type()) {
+	explicit BoundParameterData(Value val) : value(std::move(val)), return_type(value.type()) {
 	}
 
 	Value value;
@@ -39,10 +39,13 @@ 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(vector<BoundParameterData> &parameter_data) : parameter_data(parameter_data) {
 	}
 
 	bound_parameter_map_t parameters;

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

@@ -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, idx_t parameter_nr, 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/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/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

@@ -77,6 +77,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/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

@@ -15,6 +15,7 @@
 #include "duckdb/planner/operator/logical_join.hpp"
 
 namespace duckdb {
+class LogicalDelimJoin;
 
 //! LogicalComparisonJoin represents a join that involves comparisons between the LHS and RHS
 class LogicalComparisonJoin : public LogicalJoin {
@@ -27,8 +28,8 @@ 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;
 
 public:
 	string ParamsToString() const override;
@@ -37,6 +38,12 @@ public:
 	static void Deserialize(LogicalComparisonJoin &comparison_join, LogicalDeserializationState &state,
 	                        FieldReader &reader);
 
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
+	//! Turn a delim join into a regular comparison join (after all required delim scans have been pruned)
+	static unique_ptr<LogicalOperator> FromDelimJoin(LogicalDelimJoin &join);
+
 public:
 	static unique_ptr<LogicalOperator> CreateJoin(ClientContext &context, JoinType type, JoinRefType ref_type,
 	                                              unique_ptr<LogicalOperator> left_child,

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

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

@@ -21,19 +21,7 @@ public:
 public:
 	LogicalCreateIndex(unique_ptr<FunctionData> bind_data_p, unique_ptr<CreateIndexInfo> info_p,
 	                   vector<unique_ptr<Expression>> expressions_p, TableCatalogEntry &table_p,
-	                   TableFunction function_p)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_INDEX), bind_data(std::move(bind_data_p)),
-	      info(std::move(info_p)), table(table_p), function(std::move(function_p)) {
-
-		for (auto &expr : expressions_p) {
-			this->unbound_expressions.push_back(expr->Copy());
-		}
-		this->expressions = std::move(expressions_p);
-
-		if (info->column_ids.empty()) {
-			throw BinderException("CREATE INDEX does not refer to any columns in the base table!");
-		}
-	}
+	                   TableFunction function_p);
 
 	//! The bind data of the function
 	unique_ptr<FunctionData> bind_data;
@@ -53,8 +41,6 @@ public:
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 
 protected:
-	void ResolveTypes() override {
-		types.emplace_back(LogicalType::BIGINT);
-	}
+	void ResolveTypes() override;
 };
 } // namespace duckdb

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

@@ -18,9 +18,7 @@ public:
 	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_CREATE_TABLE;
 
 public:
-	LogicalCreateTable(SchemaCatalogEntry &schema, unique_ptr<BoundCreateTableInfo> info)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_TABLE), schema(schema), info(std::move(info)) {
-	}
+	LogicalCreateTable(SchemaCatalogEntry &schema, unique_ptr<BoundCreateTableInfo> info);
 
 	//! Schema to insert to
 	SchemaCatalogEntry &schema;
@@ -30,11 +28,17 @@ 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:
+	LogicalCreateTable(ClientContext &context, const string &catalog, const string &schema,
+	                   unique_ptr<CreateInfo> info);
 };
 } // namespace duckdb

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

@@ -27,5 +27,8 @@ 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);
 };
 } // namespace duckdb

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

@@ -45,6 +45,8 @@ 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;