duckdb 1.0.1-dev22.0 → 1.0.1-dev27.0

package/src/duckdb/src/parser/tableref/column_data_ref.cpp

@@ -47,33 +47,7 @@ bool ColumnDataRef::Equals(const TableRef &other_p) const {
 }
 
 unique_ptr<TableRef> ColumnDataRef::Copy() {
-	unique_ptr<ColumnDataRef> result;
-	if (collection.is_owned()) {
-		// This collection is owned, the copy should be self sufficient so it needs a copy
-		auto new_collection = make_uniq<ColumnDataCollection>(*collection);
-
-		DataChunk chunk;
-		collection->InitializeScanChunk(chunk);
-
-		ColumnDataScanState scan_state;
-		collection->InitializeScan(scan_state);
-
-		ColumnDataAppendState append_state;
-		new_collection->InitializeAppend(append_state);
-		while (collection->Scan(scan_state, chunk)) {
-			new_collection->Append(append_state, chunk);
-		}
-#ifdef DEBUG
-		string error_message;
-		if (!ColumnDataCollection::ResultEquals(*collection, *new_collection, error_message, true)) {
-			throw InternalException("Copied ColumnDataCollection was not equal: %s", error_message);
-		}
-#endif
-		result = make_uniq<ColumnDataRef>(expected_names, std::move(new_collection));
-	} else {
-		result = make_uniq<ColumnDataRef>(*collection);
-	}
-	result->expected_names = expected_names;
+	auto result = make_uniq<ColumnDataRef>(collection, expected_names);
 	CopyProperties(*result);
 	return std::move(result);
 }

package/src/duckdb/src/parser/tableref/delimgetref.cpp

@@ -0,0 +1,30 @@
+#include "duckdb/parser/tableref/delimgetref.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+
+namespace duckdb {
+
+string DelimGetRef::ToString() const {
+	return "";
+}
+
+bool DelimGetRef::Equals(const TableRef &other) const {
+	return TableRef::Equals(other);
+}
+
+unique_ptr<TableRef> DelimGetRef::Copy() {
+	return make_uniq<DelimGetRef>(types);
+}
+
+void DelimGetRef::Serialize(Serializer &serializer) const {
+	TableRef::Serialize(serializer);
+	serializer.WriteProperty<vector<LogicalType>>(105, "chunk_types", types);
+}
+
+unique_ptr<TableRef> DelimGetRef::Deserialize(Deserializer &deserializer) {
+	vector<LogicalType> types = deserializer.ReadProperty<vector<LogicalType>>(105, "chunk_types");
+	auto result = duckdb::unique_ptr<DelimGetRef>(new DelimGetRef(types));
+	return std::move(result);
+}
+
+} // namespace duckdb

package/src/duckdb/src/parser/tableref/joinref.cpp

@@ -78,6 +78,10 @@ unique_ptr<TableRef> JoinRef::Copy() {
 	copy->ref_type = ref_type;
 	copy->alias = alias;
 	copy->using_columns = using_columns;
+	copy->delim_flipped = delim_flipped;
+	for (auto &col : duplicate_eliminated_columns) {
+		copy->duplicate_eliminated_columns.emplace_back(col->Copy());
+	}
 	return std::move(copy);
 }
 

package/src/duckdb/src/parser/transform/constraint/transform_constraint.cpp

@@ -5,16 +5,12 @@
 
 namespace duckdb {
 
-static void ParseSchemaTableNameFK(duckdb_libpgquery::PGRangeVar *input, ForeignKeyInfo &fk_info) {
-	if (input->catalogname) {
+static void ParseSchemaTableNameFK(duckdb_libpgquery::PGRangeVar &input, ForeignKeyInfo &fk_info) {
+	if (input.catalogname) {
 		throw ParserException("FOREIGN KEY constraints cannot be defined cross-database");
 	}
-	if (input->schemaname) {
-		fk_info.schema = input->schemaname;
-	} else {
-		fk_info.schema = "";
-	};
-	fk_info.table = input->relname;
+	fk_info.schema = input.schemaname ? input.schemaname : "";
+	fk_info.table = input.relname;
 }
 
 static bool ForeignKeyActionSupported(char action) {
@@ -33,28 +29,34 @@ static bool ForeignKeyActionSupported(char action) {
 }
 
 static unique_ptr<ForeignKeyConstraint>
-TransformForeignKeyConstraint(duckdb_libpgquery::PGConstraint *constraint,
+TransformForeignKeyConstraint(duckdb_libpgquery::PGConstraint &constraint,
                               optional_ptr<const string> override_fk_column = nullptr) {
-	D_ASSERT(constraint);
-	if (!ForeignKeyActionSupported(constraint->fk_upd_action) ||
-	    !ForeignKeyActionSupported(constraint->fk_del_action)) {
+	if (!ForeignKeyActionSupported(constraint.fk_upd_action) || !ForeignKeyActionSupported(constraint.fk_del_action)) {
 		throw ParserException("FOREIGN KEY constraints cannot use CASCADE, SET NULL or SET DEFAULT");
 	}
+
 	ForeignKeyInfo fk_info;
 	fk_info.type = ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE;
-	ParseSchemaTableNameFK(constraint->pktable, fk_info);
-	vector<string> pk_columns, fk_columns;
+	ParseSchemaTableNameFK(*constraint.pktable, fk_info);
+
+	vector<string> pk_columns;
+	vector<string> fk_columns;
+
 	if (override_fk_column) {
-		D_ASSERT(!constraint->fk_attrs);
+		D_ASSERT(!constraint.fk_attrs);
 		fk_columns.emplace_back(*override_fk_column);
-	} else if (constraint->fk_attrs) {
-		for (auto kc = constraint->fk_attrs->head; kc; kc = kc->next) {
-			fk_columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
+
+	} else if (constraint.fk_attrs) {
+		for (auto kc = constraint.fk_attrs->head; kc; kc = kc->next) {
+			auto value = Transformer::PGPointerCast<duckdb_libpgquery::PGValue>(kc->data.ptr_value);
+			fk_columns.emplace_back(value->val.str);
 		}
 	}
-	if (constraint->pk_attrs) {
-		for (auto kc = constraint->pk_attrs->head; kc; kc = kc->next) {
-			pk_columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
+
+	if (constraint.pk_attrs) {
+		for (auto kc = constraint.pk_attrs->head; kc; kc = kc->next) {
+			auto value = Transformer::PGPointerCast<duckdb_libpgquery::PGValue>(kc->data.ptr_value);
+			pk_columns.emplace_back(value->val.str);
 		}
 	}
 	if (!pk_columns.empty() && pk_columns.size() != fk_columns.size()) {
@@ -66,9 +68,11 @@ TransformForeignKeyConstraint(duckdb_libpgquery::PGConstraint *constraint,
 	return make_uniq<ForeignKeyConstraint>(pk_columns, fk_columns, std::move(fk_info));
 }
 
-unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGListCell *cell) {
-	auto constraint = reinterpret_cast<duckdb_libpgquery::PGConstraint *>(cell->data.ptr_value);
+unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGListCell &cell) {
+
+	auto constraint = PGPointerCast<duckdb_libpgquery::PGConstraint>(cell.data.ptr_value);
 	D_ASSERT(constraint);
+
 	switch (constraint->contype) {
 	case duckdb_libpgquery::PG_CONSTR_UNIQUE:
 	case duckdb_libpgquery::PG_CONSTR_PRIMARY: {
@@ -78,7 +82,8 @@ unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGLis
 		}
 		vector<string> columns;
 		for (auto kc = constraint->keys->head; kc; kc = kc->next) {
-			columns.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(kc->data.ptr_value)->val.str);
+			auto value = PGPointerCast<duckdb_libpgquery::PGValue>(kc->data.ptr_value);
+			columns.emplace_back(value->val.str);
 		}
 		return make_uniq<UniqueConstraint>(columns, is_primary_key);
 	}
@@ -90,17 +95,18 @@ unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGLis
 		return make_uniq<CheckConstraint>(TransformExpression(constraint->raw_expr));
 	}
 	case duckdb_libpgquery::PG_CONSTR_FOREIGN:
-		return TransformForeignKeyConstraint(constraint);
-
+		return TransformForeignKeyConstraint(*constraint.get());
 	default:
 		throw NotImplementedException("Constraint type not handled yet!");
 	}
 }
 
-unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGListCell *cell, ColumnDefinition &column,
+unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGListCell &cell, ColumnDefinition &column,
                                                         idx_t index) {
-	auto constraint = reinterpret_cast<duckdb_libpgquery::PGConstraint *>(cell->data.ptr_value);
+
+	auto constraint = PGPointerCast<duckdb_libpgquery::PGConstraint>(cell.data.ptr_value);
 	D_ASSERT(constraint);
+
 	switch (constraint->contype) {
 	case duckdb_libpgquery::PG_CONSTR_NOTNULL:
 		return make_uniq<NotNullConstraint>(LogicalIndex(index));
@@ -133,7 +139,7 @@ unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGLis
 		}
 		return nullptr;
 	case duckdb_libpgquery::PG_CONSTR_FOREIGN:
-		return TransformForeignKeyConstraint(constraint, &column.Name());
+		return TransformForeignKeyConstraint(*constraint.get(), &column.Name());
 	default:
 		throw NotImplementedException("Constraint not implemented!");
 	}

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

@@ -7,71 +7,71 @@
 namespace duckdb {
 
 unique_ptr<ParsedExpression> Transformer::TransformArrayAccess(duckdb_libpgquery::PGAIndirection &indirection_node) {
-	// transform the source expression
+
+	// Transform the source expression.
 	unique_ptr<ParsedExpression> result;
 	result = TransformExpression(indirection_node.arg);
 
-	// now go over the indices
-	// note that a single indirection node can contain multiple indices
-	// this happens for e.g. more complex accesses (e.g. (foo).field1[42])
+	// Iterate the indices.
+	// For more complex expressions like (foo).field_name[42] a single indirection
+	// node can contain multiple indices.
 	idx_t list_size = 0;
 	for (auto node = indirection_node.indirection->head; node != nullptr; node = node->next) {
-		auto target = reinterpret_cast<duckdb_libpgquery::PGNode *>(node->data.ptr_value);
-		D_ASSERT(target);
+		auto target = PGPointerCast<duckdb_libpgquery::PGNode>(node->data.ptr_value);
 
 		switch (target->type) {
 		case duckdb_libpgquery::T_PGAIndices: {
-			// index access (either slice or extract)
-			auto index = PGPointerCast<duckdb_libpgquery::PGAIndices>(target);
+			// Index access.
+			auto indices = PGCast<duckdb_libpgquery::PGAIndices>(*target.get());
 			vector<unique_ptr<ParsedExpression>> children;
 			children.push_back(std::move(result));
-			if (index->is_slice) {
-				// slice
-				// if either the lower or upper bound is not specified, we use an empty const list so that we can
-				// handle it in the execution
-				unique_ptr<ParsedExpression> lower =
-				    index->lidx ? TransformExpression(index->lidx)
-				                : make_uniq<ConstantExpression>(Value::LIST(LogicalType::INTEGER, vector<Value>()));
+
+			if (indices.is_slice) {
+				// If either the lower or upper bound is not specified, we use an empty constant LIST,
+				// which we handle in the execution.
+				auto constant_list = make_uniq<ConstantExpression>(Value::LIST(LogicalType::INTEGER, vector<Value>()));
+
+				auto lower = indices.lidx ? TransformExpression(indices.lidx) : constant_list->Copy();
 				children.push_back(std::move(lower));
-				unique_ptr<ParsedExpression> upper =
-				    index->uidx ? TransformExpression(index->uidx)
-				                : make_uniq<ConstantExpression>(Value::LIST(LogicalType::INTEGER, vector<Value>()));
+				auto upper = indices.uidx ? TransformExpression(indices.uidx) : constant_list->Copy();
 				children.push_back(std::move(upper));
-				if (index->step) {
-					children.push_back(TransformExpression(index->step));
+
+				if (indices.step) {
+					children.push_back(TransformExpression(indices.step));
 				}
 				result = make_uniq<OperatorExpression>(ExpressionType::ARRAY_SLICE, std::move(children));
-			} else {
-				// array access
-				D_ASSERT(!index->lidx);
-				D_ASSERT(index->uidx);
-				children.push_back(TransformExpression(index->uidx));
-				result = make_uniq<OperatorExpression>(ExpressionType::ARRAY_EXTRACT, std::move(children));
+				break;
 			}
+
+			// Array access.
+			D_ASSERT(!indices.lidx && indices.uidx);
+			children.push_back(TransformExpression(indices.uidx));
+			result = make_uniq<OperatorExpression>(ExpressionType::ARRAY_EXTRACT, std::move(children));
 			break;
 		}
 		case duckdb_libpgquery::T_PGString: {
-			auto val = PGPointerCast<duckdb_libpgquery::PGValue>(target);
+			auto value = PGCast<duckdb_libpgquery::PGValue>(*target.get());
 			vector<unique_ptr<ParsedExpression>> children;
 			children.push_back(std::move(result));
-			children.push_back(TransformValue(*val));
+			children.push_back(TransformValue(value));
 			result = make_uniq<OperatorExpression>(ExpressionType::STRUCT_EXTRACT, std::move(children));
 			break;
 		}
 		case duckdb_libpgquery::T_PGFuncCall: {
-			auto func = PGPointerCast<duckdb_libpgquery::PGFuncCall>(target);
-			auto function = TransformFuncCall(*func);
+			auto func = PGCast<duckdb_libpgquery::PGFuncCall>(*target.get());
+			auto function = TransformFuncCall(func);
 			if (function->type != ExpressionType::FUNCTION) {
 				throw ParserException("%s.%s() call must be a function", result->ToString(), function->ToString());
 			}
-			auto &f = function->Cast<FunctionExpression>();
-			f.children.insert(f.children.begin(), std::move(result));
+			auto &function_expr = function->Cast<FunctionExpression>();
+			function_expr.children.insert(function_expr.children.begin(), std::move(result));
 			result = std::move(function);
 			break;
 		}
 		default:
 			throw NotImplementedException("Unimplemented subscript type");
 		}
+
 		list_size++;
 		StackCheck(list_size);
 	}

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

@@ -43,7 +43,7 @@ unique_ptr<ParsedExpression> Transformer::TransformStarExpression(duckdb_libpgqu
 		D_ASSERT(result->exclude_list.empty());
 		D_ASSERT(result->replace_list.empty());
 		result->expr = TransformExpression(star.expr);
-		if (result->expr->type == ExpressionType::STAR) {
+		if (StarExpression::IsStar(*result->expr)) {
 			auto &child_star = result->expr->Cast<StarExpression>();
 			result->relation_name = child_star.relation_name;
 			result->exclude_list = std::move(child_star.exclude_list);
@@ -58,6 +58,7 @@ unique_ptr<ParsedExpression> Transformer::TransformStarExpression(duckdb_libpgqu
 		}
 	}
 	result->columns = star.columns;
+	result->unpacked = star.unpacked;
 	SetQueryLocation(*result, star.location);
 	return std::move(result);
 }

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

@@ -130,6 +130,23 @@ bool Transformer::ConstructConstantFromExpression(const ParsedExpression &expr,
 			// finally create the list
 			value = Value::LIST(child_type, values);
 			return true;
+		} else if (function.function_name == "map") {
+			Value keys;
+			if (!ConstructConstantFromExpression(*function.children[0], keys)) {
+				return false;
+			}
+
+			Value values;
+			if (!ConstructConstantFromExpression(*function.children[1], values)) {
+				return false;
+			}
+
+			vector<Value> keys_unpacked = ListValue::GetChildren(keys);
+			vector<Value> values_unpacked = ListValue::GetChildren(values);
+
+			value = Value::MAP(ListType::GetChildType(keys.type()), ListType::GetChildType(values.type()),
+			                   keys_unpacked, values_unpacked);
+			return true;
 		} else {
 			return false;
 		}

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

@@ -27,6 +27,11 @@ void Transformer::TransformWindowDef(duckdb_libpgquery::PGWindowDef &window_spec
 			throw ParserException("Cannot override ORDER BY clause of window \"%s\"", window_name);
 		}
 		TransformOrderBy(window_spec.orderClause, expr.orders);
+		for (auto &order : expr.orders) {
+			if (order.expression->GetExpressionType() == ExpressionType::STAR) {
+				throw ParserException("Cannot ORDER BY ALL in a window expression");
+			}
+		}
 	}
 }
 

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

@@ -4,41 +4,43 @@
 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);
-		}
-
-		int provided_values = func.args ? func.args->length : 0;
-		// Too many columns (ie. (x, y) = (1, 2, 3) )
-		if (root.ncolumns < provided_values || !func.args) {
-			throw ParserException(
-			    "Could not perform multiple assignment, target only expects %d values, %d were provided", root.ncolumns,
-			    provided_values);
-		}
-		// 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));
+
+	// Early-out, if the root is not a function call.
+	if (root.source->type != duckdb_libpgquery::T_PGFuncCall) {
+		return TransformExpression(root.source);
+	}
+
+	auto func = PGCast<duckdb_libpgquery::PGFuncCall>(*root.source);
+
+	// Only allow ROW function.
+	auto function = PGPointerCast<duckdb_libpgquery::PGValue>(func.funcname->tail->data.ptr_value);
+	char const *function_name = function->val.str;
+	if (!function_name || !StringUtil::CIEquals(function_name, "row")) {
+		return TransformExpression(root.source);
+	}
+
+	// Too many columns, e.g., (x, y) != (1, 2, 3).
+	int64_t value_count = func.args ? func.args->length : 0;
+	if (int64_t(root.ncolumns) < value_count || !func.args) {
+		throw ParserException("Could not perform assignment, expected %d values, got %d", root.ncolumns, value_count);
 	}
-	return TransformExpression(root.source);
+
+	// Get the expression corresponding with the current column.
+	int64_t idx = 1;
+	auto list = func.args->head;
+	while (list && idx < int64_t(root.colno)) {
+		list = list->next;
+		++idx;
+	}
+
+	// Not enough columns, e.g., (x, y, z) != (1, 2).
+	if (!list) {
+		throw ParserException("Could not perform assignment, expected %d values, got %d", root.ncolumns,
+		                      func.args->length);
+	}
+
+	auto node = PGPointerCast<duckdb_libpgquery::PGNode>(list->data.ptr_value);
+	return TransformExpression(node);
 }
 
 } // namespace duckdb

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

@@ -57,6 +57,35 @@ unique_ptr<ParsedExpression> Transformer::TransformBinaryOperator(string op, uni
 	}
 }
 
+unique_ptr<ParsedExpression> Transformer::TransformInExpression(const string &name, duckdb_libpgquery::PGAExpr &root) {
+	auto left_expr = TransformExpression(root.lexpr);
+	ExpressionType operator_type;
+	// this looks very odd, but seems to be the way to find out its NOT IN
+	if (name == "<>") {
+		// NOT IN
+		operator_type = ExpressionType::COMPARE_NOT_IN;
+	} else {
+		// IN
+		operator_type = ExpressionType::COMPARE_IN;
+	}
+
+	if (root.rexpr->type == duckdb_libpgquery::T_PGList) {
+		auto result = make_uniq<OperatorExpression>(operator_type, std::move(left_expr));
+		TransformExpressionList(*PGPointerCast<duckdb_libpgquery::PGList>(root.rexpr), result->children);
+		return std::move(result);
+	}
+	auto expr = TransformExpression(*root.rexpr);
+
+	vector<unique_ptr<ParsedExpression>> children;
+	children.push_back(std::move(expr));
+	children.push_back(std::move(left_expr));
+	auto result = make_uniq_base<ParsedExpression, FunctionExpression>("contains", std::move(children));
+	if (operator_type == ExpressionType::COMPARE_NOT_IN) {
+		result = make_uniq_base<ParsedExpression, OperatorExpression>(ExpressionType::OPERATOR_NOT, std::move(result));
+	}
+	return result;
+}
+
 unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgquery::PGAExpr &root) {
 	auto name = string(PGPointerCast<duckdb_libpgquery::PGValue>(root.name->head->data.ptr_value)->val.str);
 
@@ -96,20 +125,7 @@ unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgque
 		return std::move(subquery_expr);
 	}
 	case duckdb_libpgquery::PG_AEXPR_IN: {
-		auto left_expr = TransformExpression(root.lexpr);
-		ExpressionType operator_type;
-		// this looks very odd, but seems to be the way to find out its NOT IN
-		if (name == "<>") {
-			// NOT IN
-			operator_type = ExpressionType::COMPARE_NOT_IN;
-		} else {
-			// IN
-			operator_type = ExpressionType::COMPARE_IN;
-		}
-		auto result = make_uniq<OperatorExpression>(operator_type, std::move(left_expr));
-		SetQueryLocation(*result, root.location);
-		TransformExpressionList(*PGPointerCast<duckdb_libpgquery::PGList>(root.rexpr), result->children);
-		return std::move(result);
+		return TransformInExpression(name, root);
 	}
 	// rewrite NULLIF(a, b) into CASE WHEN a=b THEN NULL ELSE a END
 	case duckdb_libpgquery::PG_AEXPR_NULLIF: {

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

@@ -24,7 +24,7 @@ void RemoveOrderQualificationRecursive(unique_ptr<ParsedExpression> &expr) {
 unique_ptr<ParsedExpression> Transformer::TransformSubquery(duckdb_libpgquery::PGSubLink &root) {
 	auto subquery_expr = make_uniq<SubqueryExpression>();
 
-	subquery_expr->subquery = TransformSelect(root.subselect);
+	subquery_expr->subquery = TransformSelectStmt(*root.subselect);
 	SetQueryLocation(*subquery_expr, root.location);
 	D_ASSERT(subquery_expr->subquery);
 	D_ASSERT(!subquery_expr->subquery->node->GetSelectList().empty());

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

@@ -8,7 +8,8 @@ vector<string> Transformer::TransformStringList(duckdb_libpgquery::PGList *list)
 		return result;
 	}
 	for (auto node = list->head; node != nullptr; node = node->next) {
-		result.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(node->data.ptr_value)->val.str);
+		auto value = PGPointerCast<duckdb_libpgquery::PGValue>(node->data.ptr_value);
+		result.emplace_back(value->val.str);
 	}
 	return result;
 }

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

@@ -1,9 +1,9 @@
-#include "duckdb/parser/transformer.hpp"
 #include "duckdb/common/enums/set_operation_type.hpp"
 #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"
+#include "duckdb/parser/query_node/recursive_cte_node.hpp"
+#include "duckdb/parser/statement/select_statement.hpp"
+#include "duckdb/parser/transformer.hpp"
 
 namespace duckdb {
 
@@ -42,8 +42,8 @@ void Transformer::TransformCTE(duckdb_libpgquery::PGWithClause &de_with_clause,
 		auto &cte = *PGPointerCast<duckdb_libpgquery::PGCommonTableExpr>(cte_ele->data.ptr_value);
 		if (cte.aliascolnames) {
 			for (auto node = cte.aliascolnames->head; node != nullptr; node = node->next) {
-				info->aliases.emplace_back(
-				    reinterpret_cast<duckdb_libpgquery::PGValue *>(node->data.ptr_value)->val.str);
+				auto value = PGPointerCast<duckdb_libpgquery::PGValue>(node->data.ptr_value);
+				info->aliases.emplace_back(value->val.str);
 			}
 		}
 		// lets throw some errors on unsupported features early
@@ -70,8 +70,7 @@ void Transformer::TransformCTE(duckdb_libpgquery::PGWithClause &de_with_clause,
 			info->query = TransformRecursiveCTE(cte, *info);
 		} else {
 			Transformer cte_transformer(*this);
-			info->query =
-			    cte_transformer.TransformSelect(*PGPointerCast<duckdb_libpgquery::PGSelectStmt>(cte.ctequery));
+			info->query = cte_transformer.TransformSelectStmt(*cte.ctequery);
 		}
 		D_ASSERT(info->query);
 		auto cte_name = string(cte.ctename);
@@ -82,12 +81,16 @@ void Transformer::TransformCTE(duckdb_libpgquery::PGWithClause &de_with_clause,
 			throw ParserException("Duplicate CTE name \"%s\"", cte_name);
 		}
 
-#ifdef DUCKDB_ALTERNATIVE_VERIFY
 		if (cte.ctematerialized == duckdb_libpgquery::PGCTEMaterializeDefault) {
+#ifdef DUCKDB_ALTERNATIVE_VERIFY
+			info->materialized = CTEMaterialize::CTE_MATERIALIZE_ALWAYS;
 #else
-		if (cte.ctematerialized == duckdb_libpgquery::PGCTEMaterializeAlways) {
+			info->materialized = CTEMaterialize::CTE_MATERIALIZE_DEFAULT;
 #endif
+		} else if (cte.ctematerialized == duckdb_libpgquery::PGCTEMaterializeAlways) {
 			info->materialized = CTEMaterialize::CTE_MATERIALIZE_ALWAYS;
+		} else if (cte.ctematerialized == duckdb_libpgquery::PGCTEMaterializeNever) {
+			info->materialized = CTEMaterialize::CTE_MATERIALIZE_NEVER;
 		}
 
 		cte_map.map[cte_name] = std::move(info);
@@ -100,25 +103,30 @@ unique_ptr<SelectStatement> Transformer::TransformRecursiveCTE(duckdb_libpgquery
 
 	unique_ptr<SelectStatement> select;
 	switch (stmt.op) {
-	case duckdb_libpgquery::PG_SETOP_UNION:
-	case duckdb_libpgquery::PG_SETOP_EXCEPT:
-	case duckdb_libpgquery::PG_SETOP_INTERSECT: {
+	case duckdb_libpgquery::PG_SETOP_UNION: {
 		select = make_uniq<SelectStatement>();
 		select->node = make_uniq_base<QueryNode, RecursiveCTENode>();
 		auto &result = select->node->Cast<RecursiveCTENode>();
 		result.ctename = string(cte.ctename);
 		result.union_all = stmt.all;
-		result.left = TransformSelectNode(*PGPointerCast<duckdb_libpgquery::PGSelectStmt>(stmt.larg));
-		result.right = TransformSelectNode(*PGPointerCast<duckdb_libpgquery::PGSelectStmt>(stmt.rarg));
-		result.aliases = info.aliases;
-		if (stmt.op != duckdb_libpgquery::PG_SETOP_UNION) {
-			throw ParserException("Unsupported setop type for recursive CTE: only UNION or UNION ALL are supported");
+		if (stmt.withClause) {
+			auto with_clause = PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause);
+			TransformCTE(*with_clause, result.cte_map);
 		}
+		result.left = TransformSelectNode(*stmt.larg);
+		result.right = TransformSelectNode(*stmt.rarg);
+		result.aliases = info.aliases;
 		break;
 	}
-	default:
+	case duckdb_libpgquery::PG_SETOP_EXCEPT:
+	case duckdb_libpgquery::PG_SETOP_INTERSECT:
+	default: {
 		// This CTE is not recursive. Fallback to regular query transformation.
-		return TransformSelect(*PGPointerCast<duckdb_libpgquery::PGSelectStmt>(cte.ctequery));
+		auto node = TransformSelectNode(*cte.ctequery);
+		auto result = make_uniq<SelectStatement>();
+		result->node = std::move(node);
+		return result;
+	}
 	}
 
 	if (stmt.limitCount || stmt.limitOffset) {