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

package/src/duckdb/src/parser/transform/helpers/transform_typename.cpp

@@ -4,6 +4,7 @@
 
 #include "duckdb/parser/transformer.hpp"
 #include "duckdb/common/types/decimal.hpp"
+#include "duckdb/common/types/vector.hpp"
 
 namespace duckdb {
 
@@ -21,7 +22,21 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName &type_n
 	if (base_type == LogicalTypeId::LIST) {
 		throw ParserException("LIST is not valid as a stand-alone type");
 	} else if (base_type == LogicalTypeId::ENUM) {
-		throw ParserException("ENUM is not valid as a stand-alone type");
+		if (!type_name.typmods || type_name.typmods->length == 0) {
+			throw ParserException("Enum needs a set of entries");
+		}
+		Vector enum_vector(LogicalType::VARCHAR, type_name.typmods->length);
+		auto string_data = FlatVector::GetData<string_t>(enum_vector);
+		idx_t pos = 0;
+		for (auto node = type_name.typmods->head; node; node = node->next) {
+			auto constant_value = PGPointerCast<duckdb_libpgquery::PGAConst>(node->data.ptr_value);
+			if (constant_value->type != duckdb_libpgquery::T_PGAConst ||
+			    constant_value->val.type != duckdb_libpgquery::T_PGString) {
+				throw ParserException("Enum type requires a set of strings as type modifiers");
+			}
+			string_data[pos++] = StringVector::AddString(enum_vector, constant_value->val.val.str);
+		}
+		return LogicalType::ENUM(enum_vector, type_name.typmods->length);
 	} else if (base_type == LogicalTypeId::STRUCT) {
 		if (!type_name.typmods || type_name.typmods->length == 0) {
 			throw ParserException("Struct needs a name and entries");

package/src/duckdb/src/parser/transform/statement/transform_copy.cpp

@@ -1,6 +1,8 @@
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/types/value.hpp"
+#include "duckdb/core_functions/scalar/struct_functions.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/statement/copy_statement.hpp"
 #include "duckdb/parser/tableref/basetableref.hpp"
 #include "duckdb/parser/transformer.hpp"
@@ -47,6 +49,17 @@ void Transformer::TransformCopyOptions(CopyInfo &info, optional_ptr<duckdb_libpg
 		case duckdb_libpgquery::T_PGAStar:
 			info.options[def_elem->defname].push_back(Value("*"));
 			break;
+		case duckdb_libpgquery::T_PGFuncCall: {
+			auto func_call = PGPointerCast<duckdb_libpgquery::PGFuncCall>(def_elem->arg);
+			auto func_expr = TransformFuncCall(*func_call);
+
+			Value value;
+			if (!Transformer::ConstructConstantFromExpression(*func_expr, value)) {
+				throw ParserException("Unsupported expression in COPY options: %s", func_expr->ToString());
+			}
+			info.options[def_elem->defname].push_back(std::move(value));
+			break;
+		}
 		default: {
 			auto val = PGPointerCast<duckdb_libpgquery::PGValue>(def_elem->arg);
 			info.options[def_elem->defname].push_back(TransformValue(*val)->value);

package/src/duckdb/src/parser/transform/statement/transform_create_index.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/parser/expression/columnref_expression.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/statement/create_statement.hpp"
 #include "duckdb/parser/parsed_data/create_index_info.hpp"
 #include "duckdb/parser/tableref/basetableref.hpp"
@@ -7,18 +8,6 @@
 
 namespace duckdb {
 
-static IndexType StringToIndexType(const string &str) {
-	string upper_str = StringUtil::Upper(str);
-	if (upper_str == "INVALID") {
-		return IndexType::INVALID;
-	} else if (upper_str == "ART") {
-		return IndexType::ART;
-	} else {
-		throw ConversionException("No IndexType conversion from string '%s'", upper_str);
-	}
-	return IndexType::INVALID;
-}
-
 vector<unique_ptr<ParsedExpression>> Transformer::TransformIndexParameters(duckdb_libpgquery::PGList &list,
                                                                            const string &relation_name) {
 	vector<unique_ptr<ParsedExpression>> expressions;
@@ -56,18 +45,44 @@ unique_ptr<CreateStatement> Transformer::TransformCreateIndex(duckdb_libpgquery:
 
 	info->expressions = TransformIndexParameters(*stmt.indexParams, stmt.relation->relname);
 
-	info->index_type = StringToIndexType(string(stmt.accessMethod));
-	auto tableref = make_uniq<BaseTableRef>();
-	tableref->table_name = stmt.relation->relname;
+	auto index_type_name = StringUtil::Upper(string(stmt.accessMethod));
+
+	if (index_type_name == "ART") {
+		info->index_type = IndexType::ART;
+	} else {
+		info->index_type = IndexType::EXTENSION;
+	}
+
+	info->index_type_name = index_type_name;
+
 	if (stmt.relation->schemaname) {
-		tableref->schema_name = stmt.relation->schemaname;
+		info->schema = stmt.relation->schemaname;
 	}
-	info->table = std::move(tableref);
+	if (stmt.relation->catalogname) {
+		info->catalog = stmt.relation->catalogname;
+	}
+	info->table = stmt.relation->relname;
 	if (stmt.idxname) {
 		info->index_name = stmt.idxname;
 	} else {
 		throw NotImplementedException("Index without a name not supported yet!");
 	}
+
+	// Parse the options list
+	if (stmt.options) {
+		duckdb_libpgquery::PGListCell *cell;
+		for_each_cell(cell, stmt.options->head) {
+			auto def_elem = PGPointerCast<duckdb_libpgquery::PGDefElem>(cell->data.ptr_value);
+			Value val;
+			if (def_elem->arg) {
+				val = TransformValue(*PGPointerCast<duckdb_libpgquery::PGValue>(def_elem->arg))->value;
+			} else {
+				val = Value::BOOLEAN(true);
+			}
+			info->options[StringUtil::Lower(def_elem->defname)] = std::move(val);
+		}
+	}
+
 	for (auto &expr : info->expressions) {
 		info->parsed_expressions.emplace_back(expr->Copy());
 	}

package/src/duckdb/src/parser/transform/statement/transform_create_type.cpp

@@ -56,7 +56,7 @@ unique_ptr<CreateStatement> Transformer::TransformCreateType(duckdb_libpgquery::
 			D_ASSERT(stmt.query == nullptr);
 			idx_t size = 0;
 			auto ordered_array = PGListToVector(stmt.vals, size);
-			info->type = LogicalType::ENUM(info->name, ordered_array, size);
+			info->type = LogicalType::ENUM(ordered_array, size);
 		}
 	} break;
 

package/src/duckdb/src/parser/transform/statement/transform_delete.cpp

@@ -5,8 +5,13 @@ namespace duckdb {
 
 unique_ptr<DeleteStatement> Transformer::TransformDelete(duckdb_libpgquery::PGDeleteStmt &stmt) {
 	auto result = make_uniq<DeleteStatement>();
+	vector<unique_ptr<CTENode>> materialized_ctes;
 	if (stmt.withClause) {
-		TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause), result->cte_map);
+		TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause), result->cte_map,
+		             materialized_ctes);
+		if (!materialized_ctes.empty()) {
+			throw NotImplementedException("Materialized CTEs are not implemented for delete.");
+		}
 	}
 
 	result->condition = TransformExpression(stmt.whereClause);

package/src/duckdb/src/parser/transform/statement/transform_insert.cpp

@@ -24,8 +24,13 @@ unique_ptr<TableRef> Transformer::TransformValuesList(duckdb_libpgquery::PGList
 
 unique_ptr<InsertStatement> Transformer::TransformInsert(duckdb_libpgquery::PGInsertStmt &stmt) {
 	auto result = make_uniq<InsertStatement>();
+	vector<unique_ptr<CTENode>> materialized_ctes;
 	if (stmt.withClause) {
-		TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause), result->cte_map);
+		TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause), result->cte_map,
+		             materialized_ctes);
+		if (!materialized_ctes.empty()) {
+			throw NotImplementedException("Materialized CTEs are not implemented for insert.");
+		}
 	}
 
 	// first check if there are any columns specified

package/src/duckdb/src/parser/transform/statement/transform_pivot_stmt.cpp

@@ -128,9 +128,11 @@ unique_ptr<QueryNode> Transformer::TransformPivotStatement(duckdb_libpgquery::PG
 	auto source = TransformTableRefNode(*pivot->source);
 
 	auto select_node = make_uniq<SelectNode>();
+	vector<unique_ptr<CTENode>> materialized_ctes;
 	// handle the CTEs
 	if (select.withClause) {
-		TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(select.withClause), select_node->cte_map);
+		TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(select.withClause), select_node->cte_map,
+		             materialized_ctes);
 	}
 	if (!pivot->columns) {
 		// no pivot columns - not actually a pivot
@@ -197,7 +199,10 @@ unique_ptr<QueryNode> Transformer::TransformPivotStatement(duckdb_libpgquery::PG
 	select_node->from_table = std::move(pivot_ref);
 	// transform order by/limit modifiers
 	TransformModifiers(select, *select_node);
-	return std::move(select_node);
+
+	auto node = Transformer::TransformMaterializedCTE(std::move(select_node), materialized_ctes);
+
+	return node;
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/transform/statement/transform_pragma.cpp

@@ -1,11 +1,12 @@
-#include "duckdb/parser/statement/pragma_statement.hpp"
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/comparison_expression.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/parser/statement/set_statement.hpp"
 #include "duckdb/common/case_insensitive_map.hpp"
+#include "duckdb/common/enum_util.hpp"
+#include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/parser/expression/columnref_expression.hpp"
+#include "duckdb/parser/expression/comparison_expression.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/statement/pragma_statement.hpp"
+#include "duckdb/parser/statement/set_statement.hpp"
+#include "duckdb/parser/transformer.hpp"
 
 namespace duckdb {
 
@@ -22,15 +23,17 @@ unique_ptr<SQLStatement> Transformer::TransformPragma(duckdb_libpgquery::PGPragm
 
 			if (expr->type == ExpressionType::COMPARE_EQUAL) {
 				auto &comp = expr->Cast<ComparisonExpression>();
-				if (comp.right->type != ExpressionType::VALUE_CONSTANT) {
-					throw ParserException("Named parameter requires a constant on the RHS");
-				}
 				if (comp.left->type != ExpressionType::COLUMN_REF) {
 					throw ParserException("Named parameter requires a column reference on the LHS");
 				}
 				auto &columnref = comp.left->Cast<ColumnRefExpression>();
-				auto &constant = comp.right->Cast<ConstantExpression>();
-				info.named_parameters[columnref.GetName()] = constant.value;
+
+				Value rhs_value;
+				if (!Transformer::ConstructConstantFromExpression(*comp.right, rhs_value)) {
+					throw ParserException("Named parameter requires a constant on the RHS");
+				}
+
+				info.named_parameters[columnref.GetName()] = rhs_value;
 			} else if (node->type == duckdb_libpgquery::T_PGAConst) {
 				auto constant = TransformConstant(*PGPointerCast<duckdb_libpgquery::PGAConst>(node.get()));
 				info.parameters.push_back((constant->Cast<ConstantExpression>()).value);

package/src/duckdb/src/parser/transform/statement/transform_prepare.cpp

@@ -2,6 +2,8 @@
 #include "duckdb/parser/statement/execute_statement.hpp"
 #include "duckdb/parser/statement/prepare_statement.hpp"
 #include "duckdb/parser/transformer.hpp"
+#include "duckdb/parser/expression/comparison_expression.hpp"
+#include "duckdb/parser/expression/columnref_expression.hpp"
 
 namespace duckdb {
 
@@ -13,26 +15,46 @@ unique_ptr<PrepareStatement> Transformer::TransformPrepare(duckdb_libpgquery::PG
 	auto result = make_uniq<PrepareStatement>();
 	result->name = string(stmt.name);
 	result->statement = TransformStatement(*stmt.query);
-	if (!result->statement->named_param_map.empty()) {
-		throw NotImplementedException("Named parameters are not supported in this client yet");
-	}
 	SetParamCount(0);
 
 	return result;
 }
 
+static string NotAcceptedExpressionException() {
+	return "Only scalar parameters, named parameters or NULL supported for EXECUTE";
+}
+
 unique_ptr<ExecuteStatement> Transformer::TransformExecute(duckdb_libpgquery::PGExecuteStmt &stmt) {
 	auto result = make_uniq<ExecuteStatement>();
 	result->name = string(stmt.name);
 
+	vector<unique_ptr<ParsedExpression>> intermediate_values;
 	if (stmt.params) {
-		TransformExpressionList(*stmt.params, result->values);
+		TransformExpressionList(*stmt.params, intermediate_values);
 	}
-	for (auto &expr : result->values) {
+
+	idx_t param_idx = 0;
+	for (idx_t i = 0; i < intermediate_values.size(); i++) {
+		auto &expr = intermediate_values[i];
 		if (!expr->IsScalar()) {
-			throw Exception("Only scalar parameters or NULL supported for EXECUTE");
+			throw InvalidInputException(NotAcceptedExpressionException());
+		}
+		if (!expr->alias.empty() && param_idx != 0) {
+			// Found unnamed parameters mixed with named parameters
+			throw NotImplementedException("Mixing named parameters and positional parameters is not supported yet");
+		}
+		auto param_name = expr->alias;
+		if (expr->alias.empty()) {
+			param_name = std::to_string(param_idx + 1);
+			if (param_idx != i) {
+				throw NotImplementedException("Mixing named parameters and positional parameters is not supported yet");
+			}
+			param_idx++;
 		}
+		expr->alias.clear();
+		result->named_values[param_name] = std::move(expr);
 	}
+	intermediate_values.clear();
 	return result;
 }
 

package/src/duckdb/src/parser/transform/statement/transform_select_node.cpp

@@ -5,6 +5,7 @@
 #include "duckdb/parser/query_node/set_operation_node.hpp"
 #include "duckdb/parser/statement/select_statement.hpp"
 #include "duckdb/parser/transformer.hpp"
+#include "duckdb/parser/query_node/cte_node.hpp"
 
 namespace duckdb {
 
@@ -45,13 +46,15 @@ unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PG
 	auto stack_checker = StackCheck();
 
 	unique_ptr<QueryNode> node;
+	vector<unique_ptr<CTENode>> materialized_ctes;
 
 	switch (stmt.op) {
 	case duckdb_libpgquery::PG_SETOP_NONE: {
 		node = make_uniq<SelectNode>();
 		auto &result = node->Cast<SelectNode>();
 		if (stmt.withClause) {
-			TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause), node->cte_map);
+			TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause), node->cte_map,
+			             materialized_ctes);
 		}
 		if (stmt.windowClause) {
 			for (auto window_ele = stmt.windowClause->head; window_ele != nullptr; window_ele = window_ele->next) {
@@ -113,7 +116,8 @@ unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PG
 		node = make_uniq<SetOperationNode>();
 		auto &result = node->Cast<SetOperationNode>();
 		if (stmt.withClause) {
-			TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause), node->cte_map);
+			TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause), node->cte_map,
+			             materialized_ctes);
 		}
 		result.left = TransformSelectNode(*stmt.larg);
 		result.right = TransformSelectNode(*stmt.rarg);
@@ -151,7 +155,12 @@ unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PG
 	default:
 		throw NotImplementedException("Statement type %d not implemented!", stmt.op);
 	}
+
 	TransformModifiers(stmt, *node);
+
+	// Handle materialized CTEs
+	node = Transformer::TransformMaterializedCTE(std::move(node), materialized_ctes);
+
 	return node;
 }
 

package/src/duckdb/src/parser/transform/statement/transform_update.cpp

@@ -19,8 +19,13 @@ unique_ptr<UpdateSetInfo> Transformer::TransformUpdateSetInfo(duckdb_libpgquery:
 
 unique_ptr<UpdateStatement> Transformer::TransformUpdate(duckdb_libpgquery::PGUpdateStmt &stmt) {
 	auto result = make_uniq<UpdateStatement>();
+	vector<unique_ptr<CTENode>> materialized_ctes;
 	if (stmt.withClause) {
-		TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause), result->cte_map);
+		TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause), result->cte_map,
+		             materialized_ctes);
+		if (!materialized_ctes.empty()) {
+			throw NotImplementedException("Materialized CTEs are not implemented for update.");
+		}
 	}
 
 	result->table = TransformRangeVar(*stmt.relation);

package/src/duckdb/src/parser/transformer.cpp

@@ -4,24 +4,11 @@
 #include "duckdb/parser/statement/list.hpp"
 #include "duckdb/parser/tableref/emptytableref.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
+#include "duckdb/parser/query_node/cte_node.hpp"
 #include "duckdb/parser/parser_options.hpp"
 
 namespace duckdb {
 
-StackChecker::StackChecker(Transformer &transformer_p, idx_t stack_usage_p)
-    : transformer(transformer_p), stack_usage(stack_usage_p) {
-	transformer.stack_depth += stack_usage;
-}
-
-StackChecker::~StackChecker() {
-	transformer.stack_depth -= stack_usage;
-}
-
-StackChecker::StackChecker(StackChecker &&other) noexcept
-    : transformer(other.transformer), stack_usage(other.stack_usage) {
-	other.stack_usage = 0;
-}
-
 Transformer::Transformer(ParserOptions &options)
     : parent(nullptr), options(options), stack_depth(DConstants::INVALID_INDEX) {
 }
@@ -58,7 +45,7 @@ void Transformer::InitializeStackCheck() {
 	stack_depth = 0;
 }
 
-StackChecker Transformer::StackCheck(idx_t extra_stack) {
+StackChecker<Transformer> Transformer::StackCheck(idx_t extra_stack) {
 	auto &root = RootTransformer();
 	D_ASSERT(root.stack_depth != DConstants::INVALID_INDEX);
 	if (root.stack_depth + extra_stack >= options.max_expression_depth) {
@@ -66,7 +53,7 @@ StackChecker Transformer::StackCheck(idx_t extra_stack) {
 		                      "increase the maximum expression depth.",
 		                      options.max_expression_depth);
 	}
-	return StackChecker(root, extra_stack);
+	return StackChecker<Transformer>(root, extra_stack);
 }
 
 unique_ptr<SQLStatement> Transformer::TransformStatement(duckdb_libpgquery::PGNode &stmt) {
@@ -104,24 +91,42 @@ void Transformer::SetParamCount(idx_t new_count) {
 	auto &root = RootTransformer();
 	root.prepared_statement_parameter_index = new_count;
 }
-void Transformer::SetNamedParam(const string &name, int32_t index) {
+
+static void ParamTypeCheck(PreparedParamType last_type, PreparedParamType new_type) {
+	// Mixing positional/auto-increment and named parameters is not supported
+	if (last_type == PreparedParamType::INVALID) {
+		return;
+	}
+	if (last_type == PreparedParamType::NAMED) {
+		if (new_type != PreparedParamType::NAMED) {
+			throw NotImplementedException("Mixing named and positional parameters is not supported yet");
+		}
+	}
+	if (last_type != PreparedParamType::NAMED) {
+		if (new_type == PreparedParamType::NAMED) {
+			throw NotImplementedException("Mixing named and positional parameters is not supported yet");
+		}
+	}
+}
+
+void Transformer::SetParam(const string &identifier, idx_t index, PreparedParamType type) {
 	auto &root = RootTransformer();
-	D_ASSERT(!root.named_param_map.count(name));
-	root.named_param_map[name] = index;
+	ParamTypeCheck(root.last_param_type, type);
+	root.last_param_type = type;
+	D_ASSERT(!root.named_param_map.count(identifier));
+	root.named_param_map[identifier] = index;
 }
-bool Transformer::GetNamedParam(const string &name, int32_t &index) {
+
+bool Transformer::GetParam(const string &identifier, idx_t &index, PreparedParamType type) {
 	auto &root = RootTransformer();
-	auto entry = root.named_param_map.find(name);
+	ParamTypeCheck(root.last_param_type, type);
+	auto entry = root.named_param_map.find(identifier);
 	if (entry == root.named_param_map.end()) {
 		return false;
 	}
 	index = entry->second;
 	return true;
 }
-bool Transformer::HasNamedParameters() const {
-	auto &root = RootTransformer();
-	return !root.named_param_map.empty();
-}
 
 unique_ptr<SQLStatement> Transformer::TransformStatementInternal(duckdb_libpgquery::PGNode &stmt) {
 	switch (stmt.type) {
@@ -209,4 +214,18 @@ unique_ptr<SQLStatement> Transformer::TransformStatementInternal(duckdb_libpgque
 	}
 }
 
+unique_ptr<QueryNode> Transformer::TransformMaterializedCTE(unique_ptr<QueryNode> root,
+                                                            vector<unique_ptr<CTENode>> &materialized_ctes) {
+	while (!materialized_ctes.empty()) {
+		unique_ptr<CTENode> node_result;
+		node_result = std::move(materialized_ctes.back());
+		node_result->cte_map = root->cte_map.Copy();
+		node_result->child = std::move(root);
+		root = std::move(node_result);
+		materialized_ctes.pop_back();
+	}
+
+	return root;
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/binder/expression/bind_macro_expression.cpp

@@ -1,12 +1,12 @@
 #include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
+#include "duckdb/common/reference_map.hpp"
 #include "duckdb/common/string_util.hpp"
+#include "duckdb/function/scalar_macro_function.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/expression/subquery_expression.hpp"
 #include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/planner/expression_binder.hpp"
 
-#include "duckdb/function/scalar_macro_function.hpp"
-
 namespace duckdb {
 
 void ExpressionBinder::ReplaceMacroParametersRecursive(unique_ptr<ParsedExpression> &expr) {
@@ -79,8 +79,10 @@ BindResult ExpressionBinder::BindMacro(FunctionExpression &function, ScalarMacro
 	new_macro_binding->arguments = &positionals;
 	macro_binding = new_macro_binding.get();
 
-	// replace current expression with stored macro expression, and replace params
+	// replace current expression with stored macro expression
 	expr = macro_def.expression->Copy();
+
+	// now replace the parameters
 	ReplaceMacroParametersRecursive(expr);
 
 	// bind the unfolded macro

package/src/duckdb/src/planner/binder/expression/bind_parameter_expression.cpp

@@ -7,34 +7,34 @@
 namespace duckdb {
 
 BindResult ExpressionBinder::BindExpression(ParameterExpression &expr, idx_t depth) {
-	D_ASSERT(expr.parameter_nr > 0);
-	auto bound_parameter = make_uniq<BoundParameterExpression>(expr.parameter_nr);
+	auto bound_parameter = make_uniq<BoundParameterExpression>(expr.identifier);
 	bound_parameter->alias = expr.alias;
 	if (!binder.parameters) {
 		throw BinderException("Unexpected prepared parameter. This type of statement can't be prepared!");
 	}
-	auto parameter_idx = expr.parameter_nr;
+	auto parameter_id = expr.identifier;
 	// check if a parameter value has already been supplied
-	if (parameter_idx <= binder.parameters->parameter_data.size()) {
+	if (binder.parameters->parameter_data.count(parameter_id)) {
 		// it has! emit a constant directly
-		auto &data = binder.parameters->parameter_data[parameter_idx - 1];
-		auto constant = make_uniq<BoundConstantExpression>(data.value);
+		auto &data = binder.parameters->parameter_data[parameter_id];
+		auto constant = make_uniq<BoundConstantExpression>(data.GetValue());
 		constant->alias = expr.alias;
 		return BindResult(std::move(constant));
 	}
-	auto entry = binder.parameters->parameters.find(parameter_idx);
+
+	auto entry = binder.parameters->parameters.find(parameter_id);
 	if (entry == binder.parameters->parameters.end()) {
 		// no entry yet: create a new one
 		auto data = make_shared<BoundParameterData>();
-		data->return_type = binder.parameters->GetReturnType(parameter_idx - 1);
+		data->return_type = binder.parameters->GetReturnType(parameter_id);
 		bound_parameter->return_type = data->return_type;
 		bound_parameter->parameter_data = data;
-		binder.parameters->parameters[parameter_idx] = std::move(data);
+		binder.parameters->parameters[parameter_id] = std::move(data);
 	} else {
 		// a prepared statement with this parameter index was already there: use it
 		auto &data = entry->second;
 		bound_parameter->parameter_data = data;
-		bound_parameter->return_type = binder.parameters->GetReturnType(parameter_idx - 1);
+		bound_parameter->return_type = binder.parameters->GetReturnType(parameter_id);
 	}
 	return BindResult(std::move(bound_parameter));
 }

package/src/duckdb/src/planner/binder/query_node/bind_cte_node.cpp

@@ -0,0 +1,64 @@
+#include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/expression_map.hpp"
+#include "duckdb/parser/query_node/select_node.hpp"
+#include "duckdb/parser/query_node/cte_node.hpp"
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/planner/query_node/bound_cte_node.hpp"
+#include "duckdb/planner/query_node/bound_select_node.hpp"
+
+namespace duckdb {
+
+unique_ptr<BoundQueryNode> Binder::BindNode(CTENode &statement) {
+	auto result = make_uniq<BoundCTENode>();
+
+	// first recursively visit the materialized CTE operations
+	// the left side is visited first and is added to the BindContext of the right side
+	D_ASSERT(statement.query);
+	D_ASSERT(statement.child);
+
+	result->ctename = statement.ctename;
+	result->setop_index = GenerateTableIndex();
+
+	result->query_binder = Binder::CreateBinder(context, this);
+	result->query = result->query_binder->BindNode(*statement.query);
+
+	// the result types of the CTE are the types of the LHS
+	result->types = result->query->types;
+	// names are picked from the LHS, unless aliases are explicitly specified
+	result->names = result->query->names;
+	for (idx_t i = 0; i < statement.aliases.size() && i < result->names.size(); i++) {
+		result->names[i] = statement.aliases[i];
+	}
+
+	// This allows the right side to reference the CTE
+	bind_context.AddGenericBinding(result->setop_index, statement.ctename, result->names, result->types);
+
+	result->child_binder = Binder::CreateBinder(context, this);
+
+	// Move all modifiers to the child node.
+	for (auto &modifier : statement.modifiers) {
+		statement.child->modifiers.push_back(std::move(modifier));
+	}
+
+	statement.modifiers.clear();
+
+	// Add bindings of left side to temporary CTE bindings context
+	result->child_binder->bind_context.AddCTEBinding(result->setop_index, statement.ctename, result->names,
+	                                                 result->types);
+	result->child = result->child_binder->BindNode(*statement.child);
+
+	// the result types of the CTE are the types of the LHS
+	result->types = result->child->types;
+	// names are picked from the LHS, unless aliases are explicitly specified
+	result->names = result->child->names;
+	for (idx_t i = 0; i < statement.aliases.size() && i < result->names.size(); i++) {
+		result->names[i] = statement.aliases[i];
+	}
+
+	MoveCorrelatedExpressions(*result->query_binder);
+	MoveCorrelatedExpressions(*result->child_binder);
+
+	return std::move(result);
+}
+
+} // namespace duckdb

package/src/duckdb/src/planner/binder/query_node/plan_cte_node.cpp

@@ -0,0 +1,26 @@
+#include "duckdb/common/string_util.hpp"
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
+#include "duckdb/planner/operator/logical_materialized_cte.hpp"
+#include "duckdb/planner/operator/logical_projection.hpp"
+#include "duckdb/planner/operator/logical_set_operation.hpp"
+#include "duckdb/planner/query_node/bound_cte_node.hpp"
+
+namespace duckdb {
+
+unique_ptr<LogicalOperator> Binder::CreatePlan(BoundCTENode &node) {
+	// Generate the logical plan for the cte_query and child.
+	auto cte_query = CreatePlan(*node.query);
+	auto cte_child = CreatePlan(*node.child);
+
+	auto root = make_uniq<LogicalMaterializedCTE>(node.ctename, node.setop_index, node.types.size(),
+	                                              std::move(cte_query), std::move(cte_child));
+
+	// check if there are any unplanned subqueries left in either child
+	has_unplanned_dependent_joins =
+	    node.child_binder->has_unplanned_dependent_joins || node.query_binder->has_unplanned_dependent_joins;
+
+	return VisitQueryNode(node, std::move(root));
+}
+
+} // namespace duckdb