duckdb 0.8.2-dev87.0 → 0.9.1-dev0.0

package/src/duckdb/src/parser/transform/expression/transform_expression.cpp

@@ -75,6 +75,8 @@ unique_ptr<ParsedExpression> Transformer::TransformExpression(duckdb_libpgquery:
 		return TransformStarExpression(PGCast<duckdb_libpgquery::PGAStar>(node));
 	case duckdb_libpgquery::T_PGBooleanTest:
 		return TransformBooleanTest(PGCast<duckdb_libpgquery::PGBooleanTest>(node));
+	case duckdb_libpgquery::T_PGMultiAssignRef:
+		return TransformMultiAssignRef(PGCast<duckdb_libpgquery::PGMultiAssignRef>(node));
 
 	default:
 		throw NotImplementedException("Expression type %s (%d)", NodetypeToString(node.type), (int)node.type);

package/src/duckdb/src/parser/transform/expression/transform_function.cpp

@@ -209,6 +209,9 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 			}
 			window_ref = it->second;
 			D_ASSERT(window_ref);
+			if (window_ref->startOffset || window_ref->endOffset || window_ref->frameOptions != FRAMEOPTION_DEFAULTS) {
+				throw ParserException("cannot copy window \"%s\" because it has a frame clause", window_spec->refname);
+			}
 		}
 		in_window_definition = true;
 		TransformWindowDef(*window_ref, *expr);

package/src/duckdb/src/parser/transform/expression/transform_multi_assign_reference.cpp

@@ -0,0 +1,44 @@
+#include "duckdb/parser/parsed_expression.hpp"
+#include "duckdb/parser/transformer.hpp"
+
+namespace duckdb {
+
+unique_ptr<ParsedExpression> Transformer::TransformMultiAssignRef(duckdb_libpgquery::PGMultiAssignRef &root) {
+	// Multi assignment for the ROW function
+	if (root.source->type == duckdb_libpgquery::T_PGFuncCall) {
+		auto func = PGCast<duckdb_libpgquery::PGFuncCall>(*root.source);
+
+		// Explicitly only allow ROW function
+		char const *function_name =
+		    PGPointerCast<duckdb_libpgquery::PGValue>(func.funcname->tail->data.ptr_value)->val.str;
+		if (function_name == nullptr || strlen(function_name) != 3 || strncmp(function_name, "row", 3) != 0) {
+			return TransformExpression(root.source);
+		}
+
+		// Too many columns (ie. (x, y) = (1, 2, 3) )
+		if (root.ncolumns < func.args->length) {
+			throw ParserException(
+			    "Could not perform multiple assignment, target only expects %d values, %d were provided", root.ncolumns,
+			    func.args->length);
+		}
+
+		// Get the expression corresponding with the current column
+		idx_t idx = 1;
+		auto list = func.args->head;
+		while (list && idx < static_cast<idx_t>(root.colno)) {
+			list = list->next;
+			++idx;
+		}
+
+		// Not enough columns (ie. (x, y, z) = (1, 2) )
+		if (!list) {
+			throw ParserException(
+			    "Could not perform multiple assignment, target expects %d values, only %d were provided", root.ncolumns,
+			    func.args->length);
+		}
+		return TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(list->data.ptr_value));
+	}
+	return TransformExpression(root.source);
+}
+
+} // namespace duckdb

package/src/duckdb/src/parser/transform/expression/transform_param_ref.cpp

@@ -4,40 +4,59 @@
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformParamRef(duckdb_libpgquery::PGParamRef &node) {
-	auto expr = make_uniq<ParameterExpression>();
+namespace {
+
+struct PreparedParam {
+	PreparedParamType type;
+	string identifier;
+};
+
+} // namespace
+
+static PreparedParam GetParameterIdentifier(duckdb_libpgquery::PGParamRef &node) {
+	PreparedParam param;
+	if (node.name) {
+		param.type = PreparedParamType::NAMED;
+		param.identifier = node.name;
+		return param;
+	}
 	if (node.number < 0) {
 		throw ParserException("Parameter numbers cannot be negative");
 	}
+	param.identifier = StringUtil::Format("%d", node.number);
+	param.type = node.number == 0 ? PreparedParamType::AUTO_INCREMENT : PreparedParamType::POSITIONAL;
+	return param;
+}
 
-	if (node.name) {
-		// This is a named parameter, try to find an entry for it
-		D_ASSERT(node.number == 0);
-		int32_t index;
-		if (GetNamedParam(node.name, index)) {
-			// We've seen this named parameter before and assigned it an index!
-			node.number = index;
-		}
-	}
-	if (node.number == 0) {
-		expr->parameter_nr = ParamCount() + 1;
-		if (node.name && !HasNamedParameters() && ParamCount() != 0) {
-			// This parameter is named, but there were other parameter before it, and they were not named
-			throw NotImplementedException("Mixing positional and named parameters is not supported yet");
+unique_ptr<ParsedExpression> Transformer::TransformParamRef(duckdb_libpgquery::PGParamRef &node) {
+	auto expr = make_uniq<ParameterExpression>();
+
+	auto param = GetParameterIdentifier(node);
+	idx_t known_param_index = DConstants::INVALID_INDEX;
+	// This is a named parameter, try to find an entry for it
+	GetParam(param.identifier, known_param_index, param.type);
+
+	if (known_param_index == DConstants::INVALID_INDEX) {
+		// We have not seen this parameter before
+		if (node.number != 0) {
+			// Preserve the parameter number
+			known_param_index = node.number;
+		} else {
+			known_param_index = ParamCount() + 1;
+			if (!node.name) {
+				param.identifier = StringUtil::Format("%d", known_param_index);
+			}
 		}
-		if (node.name) {
-			D_ASSERT(!named_param_map.count(node.name));
+
+		if (!named_param_map.count(param.identifier)) {
 			// Add it to the named parameter map so we can find it next time it's referenced
-			SetNamedParam(node.name, expr->parameter_nr);
+			SetParam(param.identifier, known_param_index, param.type);
 		}
-	} else {
-		if (!node.name && HasNamedParameters()) {
-			// This parameter does not have a name, but the named param map is not empty
-			throw NotImplementedException("Mixing positional and named parameters is not supported yet");
-		}
-		expr->parameter_nr = node.number;
 	}
-	SetParamCount(MaxValue<idx_t>(ParamCount(), expr->parameter_nr));
+
+	expr->identifier = param.identifier;
+	idx_t new_param_count = MaxValue<idx_t>(ParamCount(), known_param_index);
+	SetParamCount(new_param_count);
 	return std::move(expr);
 }
 

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

@@ -3,6 +3,7 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/parser/statement/select_statement.hpp"
 #include "duckdb/parser/query_node/recursive_cte_node.hpp"
+#include "duckdb/parser/query_node/cte_node.hpp"
 
 namespace duckdb {
 
@@ -10,6 +11,7 @@ unique_ptr<CommonTableExpressionInfo> CommonTableExpressionInfo::Copy() {
 	auto result = make_uniq<CommonTableExpressionInfo>();
 	result->aliases = aliases;
 	result->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
+	result->materialized = materialized;
 	return result;
 }
 
@@ -29,7 +31,8 @@ void Transformer::ExtractCTEsRecursive(CommonTableExpressionMap &cte_map) {
 	}
 }
 
-void Transformer::TransformCTE(duckdb_libpgquery::PGWithClause &de_with_clause, CommonTableExpressionMap &cte_map) {
+void Transformer::TransformCTE(duckdb_libpgquery::PGWithClause &de_with_clause, CommonTableExpressionMap &cte_map,
+                               vector<unique_ptr<CTENode>> &materialized_ctes) {
 	// TODO: might need to update in case of future lawsuit
 	stored_cte_map.push_back(&cte_map);
 
@@ -79,6 +82,21 @@ void Transformer::TransformCTE(duckdb_libpgquery::PGWithClause &de_with_clause,
 			// can't have two CTEs with same name
 			throw ParserException("Duplicate CTE name \"%s\"", cte_name);
 		}
+
+#ifdef DUCKDB_ALTERNATIVE_VERIFY
+		if (cte.ctematerialized == duckdb_libpgquery::PGCTEMaterializeDefault) {
+#else
+		if (cte.ctematerialized == duckdb_libpgquery::PGCTEMaterializeAlways) {
+#endif
+			auto materialize = make_uniq<CTENode>();
+			materialize->query = info->query->node->Copy();
+			materialize->ctename = cte_name;
+			materialize->aliases = info->aliases;
+			materialized_ctes.push_back(std::move(materialize));
+
+			info->materialized = CTEMaterialize::CTE_MATERIALIZE_ALWAYS;
+		}
+
 		cte_map.map[cte_name] = std::move(info);
 	}
 }

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_load.cpp

@@ -9,6 +9,7 @@ unique_ptr<LoadStatement> Transformer::TransformLoad(duckdb_libpgquery::PGLoadSt
 	auto load_stmt = make_uniq<LoadStatement>();
 	auto load_info = make_uniq<LoadInfo>();
 	load_info->filename = std::string(stmt.filename);
+	load_info->repository = std::string(stmt.repository);
 	switch (stmt.load_type) {
 	case duckdb_libpgquery::PG_LOAD_TYPE_LOAD:
 		load_info->load_type = LoadType::LOAD;

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);