duckdb 0.8.2-dev33.0 → 0.8.2-dev3334.0

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

@@ -17,7 +17,11 @@
 namespace duckdb {
 
 struct CopyInfo : public ParseInfo {
-	CopyInfo() : catalog(INVALID_CATALOG), schema(DEFAULT_SCHEMA) {
+public:
+	static constexpr const ParseInfoType TYPE = ParseInfoType::COPY_INFO;
+
+public:
+	CopyInfo() : ParseInfo(TYPE), catalog(INVALID_CATALOG), schema(DEFAULT_SCHEMA) {
 	}
 
 	//! The catalog name to copy to/from
@@ -50,6 +54,9 @@ public:
 		result->options = options;
 		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/create_index_info.hpp

@@ -25,10 +25,12 @@ struct CreateIndexInfo : public CreateInfo {
 	IndexType index_type;
 	//! Name of the Index
 	string index_name;
+	//! Name of the Index type
+	string index_type_name;
 	//! Index Constraint Type
 	IndexConstraintType constraint_type;
 	//! The table to create the index on
-	unique_ptr<BaseTableRef> table;
+	string table;
 	//! Set of expressions to index by
 	vector<unique_ptr<ParsedExpression>> expressions;
 	vector<unique_ptr<ParsedExpression>> parsed_expressions;
@@ -40,6 +42,9 @@ struct CreateIndexInfo : public CreateInfo {
 	//! Column IDs needed for index creation
 	vector<column_t> column_ids;
 
+	//! Options values (WITH ...)
+	case_insensitive_map_t<Value> options;
+
 protected:
 	void SerializeInternal(Serializer &serializer) const override;
 
@@ -47,6 +52,9 @@ public:
 	DUCKDB_API unique_ptr<CreateInfo> Copy() const override;
 
 	static unique_ptr<CreateIndexInfo> Deserialize(Deserializer &deserializer);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<CreateInfo> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

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

@@ -28,9 +28,13 @@ enum class OnCreateConflict : uint8_t {
 };
 
 struct CreateInfo : public ParseInfo {
+public:
+	static constexpr const ParseInfoType TYPE = ParseInfoType::CREATE_INFO;
+
+public:
 	explicit CreateInfo(CatalogType type, string schema = DEFAULT_SCHEMA, string catalog_p = INVALID_CATALOG)
-	    : type(type), catalog(std::move(catalog_p)), schema(schema), on_conflict(OnCreateConflict::ERROR_ON_CONFLICT),
-	      temporary(false), internal(false) {
+	    : ParseInfo(TYPE), type(type), catalog(std::move(catalog_p)), schema(schema),
+	      on_conflict(OnCreateConflict::ERROR_ON_CONFLICT), temporary(false), internal(false) {
 	}
 	~CreateInfo() override {
 	}
@@ -61,6 +65,9 @@ public:
 	static unique_ptr<CreateInfo> Deserialize(Deserializer &deserializer);
 	static unique_ptr<CreateInfo> Deserialize(Deserializer &deserializer, PlanDeserializationState &state);
 
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<CreateInfo> FormatDeserialize(FormatDeserializer &deserializer);
+
 	virtual unique_ptr<CreateInfo> Copy() const = 0;
 
 	DUCKDB_API void CopyProperties(CreateInfo &other) const;

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

@@ -24,6 +24,9 @@ public:
 
 	DUCKDB_API static unique_ptr<CreateMacroInfo> Deserialize(Deserializer &deserializer);
 
+	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const override;
+	DUCKDB_API static unique_ptr<CreateInfo> FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	void SerializeInternal(Serializer &) const override;
 };

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

@@ -29,6 +29,9 @@ public:
 		return result;
 	}
 
+	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const override;
+	DUCKDB_API static unique_ptr<CreateInfo> FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	void SerializeInternal(Serializer &) const override {
 	}

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

@@ -52,6 +52,9 @@ public:
 public:
 	DUCKDB_API static unique_ptr<CreateSequenceInfo> Deserialize(Deserializer &deserializer);
 
+	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const override;
+	DUCKDB_API static unique_ptr<CreateInfo> FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	void SerializeInternal(Serializer &) const override;
 };

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

@@ -40,6 +40,9 @@ public:
 	DUCKDB_API static unique_ptr<CreateTableInfo> Deserialize(Deserializer &deserializer);
 
 	DUCKDB_API unique_ptr<CreateInfo> Copy() const override;
+
+	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const override;
+	DUCKDB_API static unique_ptr<CreateInfo> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

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

@@ -31,6 +31,9 @@ public:
 
 	DUCKDB_API static unique_ptr<CreateTypeInfo> Deserialize(Deserializer &deserializer);
 
+	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const override;
+	DUCKDB_API static unique_ptr<CreateInfo> FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	void SerializeInternal(Serializer &) const override;
 };

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

@@ -38,6 +38,9 @@ public:
 	//! Gets a bound CreateViewInfo object from a CREATE VIEW statement
 	DUCKDB_API static unique_ptr<CreateViewInfo> FromCreateView(ClientContext &context, const string &sql);
 
+	DUCKDB_API void FormatSerialize(FormatSerializer &serializer) const override;
+	DUCKDB_API static unique_ptr<CreateInfo> FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	void SerializeInternal(Serializer &serializer) const override;
 };

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,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/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