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

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

@@ -14,6 +14,10 @@
 namespace duckdb {
 
 struct DetachInfo : public ParseInfo {
+public:
+	static constexpr const ParseInfoType TYPE = ParseInfoType::DETACH_INFO;
+
+public:
 	DetachInfo();
 
 	//! The alias of the attached database
@@ -25,5 +29,8 @@ public:
 	unique_ptr<DetachInfo> Copy() const;
 	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/parser/parsed_data/drop_info.hpp

@@ -15,6 +15,10 @@
 namespace duckdb {
 
 struct DropInfo : public ParseInfo {
+public:
+	static constexpr const ParseInfoType TYPE = ParseInfoType::DROP_INFO;
+
+public:
 	DropInfo();
 
 	//! The catalog type to drop
@@ -38,6 +42,9 @@ 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/parser/parsed_data/exported_table_data.hpp

@@ -38,6 +38,13 @@ struct ExportedTableInfo {
 };
 
 struct BoundExportData : public ParseInfo {
+public:
+	static constexpr const ParseInfoType TYPE = ParseInfoType::BOUND_EXPORT_DATA;
+
+public:
+	BoundExportData() : ParseInfo(TYPE) {
+	}
+
 	vector<ExportedTableInfo> data;
 };
 

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,16 +13,25 @@
 
 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;
+	string repository;
 	LoadType load_type;
 
 public:
 	unique_ptr<LoadInfo> Copy() const {
 		auto result = make_uniq<LoadInfo>();
 		result->filename = filename;
+		result->repository = repository;
 		result->load_type = load_type;
 		return result;
 	}
@@ -30,6 +39,7 @@ public:
 	void Serialize(Serializer &serializer) const {
 		FieldWriter writer(serializer);
 		writer.WriteString(filename);
+		writer.WriteString(repository);
 		writer.WriteField<LoadType>(load_type);
 		writer.Finalize();
 	}
@@ -38,10 +48,14 @@ public:
 		FieldReader reader(deserializer);
 		auto load_info = make_uniq<LoadInfo>();
 		load_info->filename = reader.ReadRequired<string>();
+		load_info->repository = reader.ReadRequired<string>();
 		load_info->load_type = reader.ReadRequired<LoadType>();
 		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/parser/parser.hpp

@@ -22,6 +22,8 @@ struct PGList;
 
 namespace duckdb {
 
+class GroupByNode;
+
 //! The parser is responsible for parsing the query and converting it into a set
 //! of parsed statements. The parsed statements can then be converted into a
 //! plan and executed.
@@ -50,6 +52,8 @@ public:
 	//! Parses a list of expressions (i.e. the list found in a SELECT clause)
 	DUCKDB_API static vector<unique_ptr<ParsedExpression>> ParseExpressionList(const string &select_list,
 	                                                                           ParserOptions options = ParserOptions());
+	//! Parses a list of GROUP BY expressions
+	static GroupByNode ParseGroupByList(const string &group_by, ParserOptions options = ParserOptions());
 	//! Parses a list as found in an ORDER BY expression (i.e. including optional ASCENDING/DESCENDING modifiers)
 	static vector<OrderByNode> ParseOrderList(const string &select_list, ParserOptions options = ParserOptions());
 	//! Parses an update list (i.e. the list found in the SET clause of an UPDATE statement)

package/src/duckdb/src/include/duckdb/parser/query_node/cte_node.hpp

@@ -0,0 +1,54 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/query_node/cte_node.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/parser/parsed_expression.hpp"
+#include "duckdb/parser/query_node.hpp"
+#include "duckdb/parser/sql_statement.hpp"
+
+namespace duckdb {
+
+class CTENode : public QueryNode {
+public:
+	static constexpr const QueryNodeType TYPE = QueryNodeType::CTE_NODE;
+
+public:
+	CTENode() : QueryNode(QueryNodeType::CTE_NODE) {
+	}
+
+	string ctename;
+	//! The query of the CTE
+	unique_ptr<QueryNode> query;
+	//! Child
+	unique_ptr<QueryNode> child;
+	//! Aliases of the CTE node
+	vector<string> aliases;
+
+	const vector<unique_ptr<ParsedExpression>> &GetSelectList() const override {
+		return query->GetSelectList();
+	}
+
+public:
+	//! Convert the query node to a string
+	string ToString() const override;
+
+	bool Equals(const QueryNode *other) const override;
+	//! Create a copy of this SelectNode
+	unique_ptr<QueryNode> Copy() const override;
+
+	//! Serializes a QueryNode to a stand-alone binary blob
+	void Serialize(FieldWriter &writer) const override;
+	//! Deserializes a blob back into a QueryNode
+	static unique_ptr<QueryNode> Deserialize(FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<QueryNode> FormatDeserialize(FormatDeserializer &source);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/query_node/list.hpp

@@ -1,3 +1,4 @@
 #include "duckdb/parser/query_node/recursive_cte_node.hpp"
+#include "duckdb/parser/query_node/cte_node.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/query_node/set_operation_node.hpp"

package/src/duckdb/src/include/duckdb/parser/query_node.hpp

@@ -25,7 +25,8 @@ enum class QueryNodeType : uint8_t {
 	SELECT_NODE = 1,
 	SET_OPERATION_NODE = 2,
 	BOUND_SUBQUERY_NODE = 3,
-	RECURSIVE_CTE_NODE = 4
+	RECURSIVE_CTE_NODE = 4,
+	CTE_NODE = 5
 };
 
 struct CommonTableExpressionInfo;

package/src/duckdb/src/include/duckdb/parser/statement/execute_statement.hpp

@@ -22,7 +22,7 @@ public:
 	ExecuteStatement();
 
 	string name;
-	vector<unique_ptr<ParsedExpression>> values;
+	case_insensitive_map_t<unique_ptr<ParsedExpression>> named_values;
 
 protected:
 	ExecuteStatement(const ExecuteStatement &other);

package/src/duckdb/src/include/duckdb/parser/tableref/emptytableref.hpp

@@ -31,6 +31,7 @@ public:
 	//! Deserializes a blob back into a DummyTableRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
 
+	void FormatSerialize(FormatSerializer &serializer) const override;
 	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/tableref/joinref.hpp

@@ -23,7 +23,7 @@ public:
 	static constexpr const TableReferenceType TYPE = TableReferenceType::JOIN;
 
 public:
-	explicit JoinRef(JoinRefType ref_type)
+	explicit JoinRef(JoinRefType ref_type = JoinRefType::REGULAR)
 	    : TableRef(TableReferenceType::JOIN), type(JoinType::INNER), ref_type(ref_type) {
 	}
 

package/src/duckdb/src/include/duckdb/parser/tableref/subqueryref.hpp

@@ -17,6 +17,9 @@ class SubqueryRef : public TableRef {
 public:
 	static constexpr const TableReferenceType TYPE = TableReferenceType::SUBQUERY;
 
+private:
+	SubqueryRef();
+
 public:
 	DUCKDB_API explicit SubqueryRef(unique_ptr<SelectStatement> subquery, string alias = string());
 

package/src/duckdb/src/include/duckdb/parser/tokens.hpp

@@ -50,6 +50,7 @@ class QueryNode;
 class SelectNode;
 class SetOperationNode;
 class RecursiveCTENode;
+class CTENode;
 
 //===--------------------------------------------------------------------===//
 // Expressions

package/src/duckdb/src/include/duckdb/parser/transformer.hpp

@@ -8,25 +8,26 @@
 
 #pragma once
 
+#include "duckdb/common/case_insensitive_map.hpp"
 #include "duckdb/common/constants.hpp"
 #include "duckdb/common/enums/expression_type.hpp"
+#include "duckdb/common/stack_checker.hpp"
 #include "duckdb/common/types.hpp"
 #include "duckdb/common/unordered_map.hpp"
-#include "duckdb/parser/qualified_name.hpp"
-#include "duckdb/parser/tokens.hpp"
-#include "duckdb/parser/parsed_data/create_info.hpp"
 #include "duckdb/parser/group_by_node.hpp"
+#include "duckdb/parser/parsed_data/create_info.hpp"
+#include "duckdb/parser/qualified_name.hpp"
 #include "duckdb/parser/query_node.hpp"
-#include "duckdb/common/case_insensitive_map.hpp"
-
-#include "pg_definitions.hpp"
+#include "duckdb/parser/query_node/cte_node.hpp"
+#include "duckdb/parser/tokens.hpp"
 #include "nodes/parsenodes.hpp"
 #include "nodes/primnodes.hpp"
+#include "pg_definitions.hpp"
+#include "duckdb/parser/expression/parameter_expression.hpp"
 
 namespace duckdb {
 
 class ColumnDefinition;
-class StackChecker;
 struct OrderByNode;
 struct CopyInfo;
 struct CommonTableExpressionInfo;
@@ -39,7 +40,7 @@ struct PivotColumn;
 //! The transformer class is responsible for transforming the internal Postgres
 //! parser representation into the DuckDB representation
 class Transformer {
-	friend class StackChecker;
+	friend class StackChecker<Transformer>;
 
 	struct CreatePivotEntry {
 		string enum_name;
@@ -67,6 +68,8 @@ private:
 	idx_t prepared_statement_parameter_index = 0;
 	//! Map from named parameter to parameter index;
 	case_insensitive_map_t<idx_t> named_param_map;
+	//! Last parameter type
+	PreparedParamType last_param_type = PreparedParamType::INVALID;
 	//! Holds window expressions defined by name. We need those when transforming the expressions referring to them.
 	unordered_map<string, duckdb_libpgquery::PGWindowDef *> window_clauses;
 	//! The set of pivot entries to create
@@ -82,9 +85,8 @@ private:
 	Transformer &RootTransformer();
 	const Transformer &RootTransformer() const;
 	void SetParamCount(idx_t new_count);
-	void SetNamedParam(const string &name, int32_t index);
-	bool GetNamedParam(const string &name, int32_t &index);
-	bool HasNamedParameters() const;
+	void SetParam(const string &name, idx_t index, PreparedParamType type);
+	bool GetParam(const string &name, idx_t &index, PreparedParamType type);
 
 	void AddPivotEntry(string enum_name, unique_ptr<SelectNode> source, unique_ptr<ParsedExpression> column,
 	                   unique_ptr<QueryNode> subquery);
@@ -232,6 +234,9 @@ private:
 	unique_ptr<ParsedExpression> TransformParamRef(duckdb_libpgquery::PGParamRef &node);
 	unique_ptr<ParsedExpression> TransformNamedArg(duckdb_libpgquery::PGNamedArgExpr &root);
 
+	//! Transform multi assignment reference into an Expression
+	unique_ptr<ParsedExpression> TransformMultiAssignRef(duckdb_libpgquery::PGMultiAssignRef &root);
+
 	unique_ptr<ParsedExpression> TransformSQLValueFunction(duckdb_libpgquery::PGSQLValueFunction &node);
 
 	unique_ptr<ParsedExpression> TransformSubquery(duckdb_libpgquery::PGSubLink &root);
@@ -269,13 +274,17 @@ private:
 	OnCreateConflict TransformOnConflict(duckdb_libpgquery::PGOnCreateConflict conflict);
 	string TransformAlias(duckdb_libpgquery::PGAlias *root, vector<string> &column_name_alias);
 	vector<string> TransformStringList(duckdb_libpgquery::PGList *list);
-	void TransformCTE(duckdb_libpgquery::PGWithClause &de_with_clause, CommonTableExpressionMap &cte_map);
-	unique_ptr<SelectStatement> TransformRecursiveCTE(duckdb_libpgquery::PGCommonTableExpr &cte,
+	void TransformCTE(duckdb_libpgquery::PGWithClause &de_with_clause, CommonTableExpressionMap &cte_map,
+	                  vector<unique_ptr<CTENode>> &materialized_ctes);
+	static unique_ptr<QueryNode> TransformMaterializedCTE(unique_ptr<QueryNode> root,
+	                                                      vector<unique_ptr<CTENode>> &materialized_ctes);
+	unique_ptr<SelectStatement> TransformRecursiveCTE(duckdb_libpgquery::PGCommonTableExpr &node,
 	                                                  CommonTableExpressionInfo &info);
 
 	unique_ptr<ParsedExpression> TransformUnaryOperator(const string &op, unique_ptr<ParsedExpression> child);
 	unique_ptr<ParsedExpression> TransformBinaryOperator(string op, unique_ptr<ParsedExpression> left,
 	                                                     unique_ptr<ParsedExpression> right);
+	static bool ConstructConstantFromExpression(const ParsedExpression &expr, Value &value);
 	//===--------------------------------------------------------------------===//
 	// TableRef transform
 	//===--------------------------------------------------------------------===//
@@ -336,7 +345,7 @@ private:
 	idx_t stack_depth;
 
 	void InitializeStackCheck();
-	StackChecker StackCheck(idx_t extra_stack = 1);
+	StackChecker<Transformer> StackCheck(idx_t extra_stack = 1);
 
 public:
 	template <class T>
@@ -349,18 +358,6 @@ public:
 	}
 };
 
-class StackChecker {
-public:
-	StackChecker(Transformer &transformer, idx_t stack_usage);
-	~StackChecker();
-	StackChecker(StackChecker &&) noexcept;
-	StackChecker(const StackChecker &) = delete;
-
-private:
-	Transformer &transformer;
-	idx_t stack_usage;
-};
-
 vector<string> ReadPgListToString(duckdb_libpgquery::PGList *column_list);
 
 } // namespace duckdb

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

@@ -21,6 +21,7 @@
 #include "duckdb/planner/bound_tokens.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/planner/logical_operator.hpp"
+#include "duckdb/planner/joinside.hpp"
 #include "duckdb/common/reference_map.hpp"
 
 namespace duckdb {
@@ -75,7 +76,7 @@ struct CorrelatedColumnInfo {
 */
 class Binder : public std::enable_shared_from_this<Binder> {
 	friend class ExpressionBinder;
-	friend class RecursiveSubqueryPlanner;
+	friend class RecursiveDependentJoinPlanner;
 
 public:
 	DUCKDB_API static shared_ptr<Binder> CreateBinder(ClientContext &context, optional_ptr<Binder> parent = nullptr,
@@ -199,10 +200,10 @@ private:
 	vector<reference<ExpressionBinder>> active_binders;
 	//! The count of bound_tables
 	idx_t bound_tables;
-	//! Whether or not the binder has any unplanned subqueries that still need to be planned
-	bool has_unplanned_subqueries = false;
-	//! Whether or not subqueries should be planned already
-	bool plan_subquery = true;
+	//! Whether or not the binder has any unplanned dependent joins that still need to be planned/flattened
+	bool has_unplanned_dependent_joins = false;
+	//! Whether or not outside dependent joins have been planned and flattened
+	bool is_outside_flattened = true;
 	//! Whether CTEs should reference the parent binder (if it exists)
 	bool inherit_ctes = true;
 	//! Whether or not the binder can contain NULLs as the root of expressions
@@ -217,6 +218,10 @@ private:
 	reference_set_t<ViewCatalogEntry> bound_views;
 
 private:
+	//! Get the root binder (binder with no parent)
+	Binder *GetRootBinder();
+	//! Determine the depth of the binder
+	idx_t GetBinderDepth() const;
 	//! Bind the expressions of generated columns to check for errors
 	void BindGeneratedColumns(BoundCreateTableInfo &info);
 	//! Bind the default values of the columns of a table
@@ -229,6 +234,10 @@ private:
 	//! Move correlated expressions from the child binder to this binder
 	void MoveCorrelatedExpressions(Binder &other);
 
+	//! Tries to bind the table name with replacement scans
+	unique_ptr<BoundTableRef> BindWithReplacementScan(ClientContext &context, const string &table_name,
+	                                                  BaseTableRef &ref);
+
 	BoundStatement Bind(SelectStatement &stmt);
 	BoundStatement Bind(InsertStatement &stmt);
 	BoundStatement Bind(CopyStatement &stmt);
@@ -265,10 +274,12 @@ private:
 	unique_ptr<BoundQueryNode> BindNode(SelectNode &node);
 	unique_ptr<BoundQueryNode> BindNode(SetOperationNode &node);
 	unique_ptr<BoundQueryNode> BindNode(RecursiveCTENode &node);
+	unique_ptr<BoundQueryNode> BindNode(CTENode &node);
 	unique_ptr<BoundQueryNode> BindNode(QueryNode &node);
 
 	unique_ptr<LogicalOperator> VisitQueryNode(BoundQueryNode &node, unique_ptr<LogicalOperator> root);
 	unique_ptr<LogicalOperator> CreatePlan(BoundRecursiveCTENode &node);
+	unique_ptr<LogicalOperator> CreatePlan(BoundCTENode &node);
 	unique_ptr<LogicalOperator> CreatePlan(BoundSelectNode &statement);
 	unique_ptr<LogicalOperator> CreatePlan(BoundSetOperationNode &node);
 	unique_ptr<LogicalOperator> CreatePlan(BoundQueryNode &node);

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_parameter_map.hpp

@@ -10,11 +10,12 @@
 
 #include "duckdb/common/types.hpp"
 #include "duckdb/common/unordered_map.hpp"
+#include "duckdb/common/case_insensitive_map.hpp"
 
 namespace duckdb {
 
 struct BoundParameterData;
 
-using bound_parameter_map_t = unordered_map<idx_t, shared_ptr<BoundParameterData>>;
+using bound_parameter_map_t = case_insensitive_map_t<shared_ptr<BoundParameterData>>;
 
 } // namespace duckdb

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/bound_tokens.hpp

@@ -17,6 +17,7 @@ class BoundQueryNode;
 class BoundSelectNode;
 class BoundSetOperationNode;
 class BoundRecursiveCTENode;
+class BoundCTENode;
 
 //===--------------------------------------------------------------------===//
 // Expressions

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;
@@ -32,6 +34,13 @@ struct ColumnBinding {
 	bool operator==(const ColumnBinding &rhs) const {
 		return table_index == rhs.table_index && column_index == rhs.column_index;
 	}
+
+	bool operator!=(const ColumnBinding &rhs) const {
+		return !(*this == rhs);
+	}
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static ColumnBinding FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb