duckdb 0.8.1-dev0.0 → 0.8.1-dev111.0

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

@@ -57,17 +57,16 @@ unique_ptr<ParsedExpression> Transformer::TransformBinaryOperator(string op, uni
 	}
 }
 
-unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgquery::PGAExpr *root) {
-	D_ASSERT(root);
-	auto name = string((reinterpret_cast<duckdb_libpgquery::PGValue *>(root->name->head->data.ptr_value))->val.str);
+unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgquery::PGAExpr &root) {
+	auto name = string(PGPointerCast<duckdb_libpgquery::PGValue>(root.name->head->data.ptr_value)->val.str);
 
-	switch (root->kind) {
+	switch (root.kind) {
 	case duckdb_libpgquery::PG_AEXPR_OP_ALL:
 	case duckdb_libpgquery::PG_AEXPR_OP_ANY: {
 		// left=ANY(right)
 		// we turn this into left=ANY((SELECT UNNEST(right)))
-		auto left_expr = TransformExpression(root->lexpr);
-		auto right_expr = TransformExpression(root->rexpr);
+		auto left_expr = TransformExpression(root.lexpr);
+		auto right_expr = TransformExpression(root.rexpr);
 
 		auto subquery_expr = make_uniq<SubqueryExpression>();
 		auto select_statement = make_uniq<SelectStatement>();
@@ -82,9 +81,9 @@ unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgque
 		subquery_expr->subquery_type = SubqueryType::ANY;
 		subquery_expr->child = std::move(left_expr);
 		subquery_expr->comparison_type = OperatorToExpressionType(name);
-		subquery_expr->query_location = root->location;
+		subquery_expr->query_location = root.location;
 
-		if (root->kind == duckdb_libpgquery::PG_AEXPR_OP_ALL) {
+		if (root.kind == duckdb_libpgquery::PG_AEXPR_OP_ALL) {
 			// ALL sublink is equivalent to NOT(ANY) with inverted comparison
 			// e.g. [= ALL()] is equivalent to [NOT(<> ANY())]
 			// first invert the comparison type
@@ -94,7 +93,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);
+		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 == "<>") {
@@ -105,35 +104,35 @@ unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgque
 			operator_type = ExpressionType::COMPARE_IN;
 		}
 		auto result = make_uniq<OperatorExpression>(operator_type, std::move(left_expr));
-		result->query_location = root->location;
-		TransformExpressionList(*((duckdb_libpgquery::PGList *)root->rexpr), result->children);
+		result->query_location = root.location;
+		TransformExpressionList(*PGPointerCast<duckdb_libpgquery::PGList>(root.rexpr), result->children);
 		return std::move(result);
 	}
 	// rewrite NULLIF(a, b) into CASE WHEN a=b THEN NULL ELSE a END
 	case duckdb_libpgquery::PG_AEXPR_NULLIF: {
 		vector<unique_ptr<ParsedExpression>> children;
-		children.push_back(TransformExpression(root->lexpr));
-		children.push_back(TransformExpression(root->rexpr));
+		children.push_back(TransformExpression(root.lexpr));
+		children.push_back(TransformExpression(root.rexpr));
 		return make_uniq<FunctionExpression>("nullif", std::move(children));
 	}
 	// rewrite (NOT) X BETWEEN A AND B into (NOT) AND(GREATERTHANOREQUALTO(X,
 	// A), LESSTHANOREQUALTO(X, B))
 	case duckdb_libpgquery::PG_AEXPR_BETWEEN:
 	case duckdb_libpgquery::PG_AEXPR_NOT_BETWEEN: {
-		auto between_args = reinterpret_cast<duckdb_libpgquery::PGList *>(root->rexpr);
+		auto between_args = PGPointerCast<duckdb_libpgquery::PGList>(root.rexpr);
 		if (between_args->length != 2 || !between_args->head->data.ptr_value || !between_args->tail->data.ptr_value) {
 			throw InternalException("(NOT) BETWEEN needs two args");
 		}
 
-		auto input = TransformExpression(root->lexpr);
+		auto input = TransformExpression(root.lexpr);
 		auto between_left =
-		    TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(between_args->head->data.ptr_value));
+		    TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(between_args->head->data.ptr_value));
 		auto between_right =
-		    TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(between_args->tail->data.ptr_value));
+		    TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(between_args->tail->data.ptr_value));
 
 		auto compare_between =
 		    make_uniq<BetweenExpression>(std::move(input), std::move(between_left), std::move(between_right));
-		if (root->kind == duckdb_libpgquery::PG_AEXPR_BETWEEN) {
+		if (root.kind == duckdb_libpgquery::PG_AEXPR_BETWEEN) {
 			return std::move(compare_between);
 		} else {
 			return make_uniq<OperatorExpression>(ExpressionType::OPERATOR_NOT, std::move(compare_between));
@@ -141,13 +140,13 @@ unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgque
 	}
 	// rewrite SIMILAR TO into regexp_full_match('asdf', '.*sd.*')
 	case duckdb_libpgquery::PG_AEXPR_SIMILAR: {
-		auto left_expr = TransformExpression(root->lexpr);
-		auto right_expr = TransformExpression(root->rexpr);
+		auto left_expr = TransformExpression(root.lexpr);
+		auto right_expr = TransformExpression(root.rexpr);
 
 		vector<unique_ptr<ParsedExpression>> children;
 		children.push_back(std::move(left_expr));
 
-		auto &similar_func = reinterpret_cast<FunctionExpression &>(*right_expr);
+		auto &similar_func = right_expr->Cast<FunctionExpression>();
 		D_ASSERT(similar_func.function_name == "similar_escape");
 		D_ASSERT(similar_func.children.size() == 2);
 		if (similar_func.children[1]->type != ExpressionType::VALUE_CONSTANT) {
@@ -176,14 +175,14 @@ unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgque
 		}
 	}
 	case duckdb_libpgquery::PG_AEXPR_NOT_DISTINCT: {
-		auto left_expr = TransformExpression(root->lexpr);
-		auto right_expr = TransformExpression(root->rexpr);
+		auto left_expr = TransformExpression(root.lexpr);
+		auto right_expr = TransformExpression(root.rexpr);
 		return make_uniq<ComparisonExpression>(ExpressionType::COMPARE_NOT_DISTINCT_FROM, std::move(left_expr),
 		                                       std::move(right_expr));
 	}
 	case duckdb_libpgquery::PG_AEXPR_DISTINCT: {
-		auto left_expr = TransformExpression(root->lexpr);
-		auto right_expr = TransformExpression(root->rexpr);
+		auto left_expr = TransformExpression(root.lexpr);
+		auto right_expr = TransformExpression(root.rexpr);
 		return make_uniq<ComparisonExpression>(ExpressionType::COMPARE_DISTINCT_FROM, std::move(left_expr),
 		                                       std::move(right_expr));
 	}
@@ -191,8 +190,8 @@ unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgque
 	default:
 		break;
 	}
-	auto left_expr = TransformExpression(root->lexpr);
-	auto right_expr = TransformExpression(root->rexpr);
+	auto left_expr = TransformExpression(root.lexpr);
+	auto right_expr = TransformExpression(root.rexpr);
 
 	if (!left_expr) {
 		// prefix operator
@@ -205,10 +204,10 @@ unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgque
 	}
 }
 
-unique_ptr<ParsedExpression> Transformer::TransformAExpr(duckdb_libpgquery::PGAExpr *root) {
+unique_ptr<ParsedExpression> Transformer::TransformAExpr(duckdb_libpgquery::PGAExpr &root) {
 	auto result = TransformAExprInternal(root);
 	if (result) {
-		result->query_location = root->location;
+		result->query_location = root.location;
 	}
 	return result;
 }

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

@@ -4,39 +4,38 @@
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformParamRef(duckdb_libpgquery::PGParamRef *node) {
-	D_ASSERT(node);
+unique_ptr<ParsedExpression> Transformer::TransformParamRef(duckdb_libpgquery::PGParamRef &node) {
 	auto expr = make_uniq<ParameterExpression>();
-	if (node->number < 0) {
+	if (node.number < 0) {
 		throw ParserException("Parameter numbers cannot be negative");
 	}
 
-	if (node->name) {
+	if (node.name) {
 		// This is a named parameter, try to find an entry for it
-		D_ASSERT(node->number == 0);
+		D_ASSERT(node.number == 0);
 		int32_t index;
-		if (GetNamedParam(node->name, index)) {
+		if (GetNamedParam(node.name, index)) {
 			// We've seen this named parameter before and assigned it an index!
-			node->number = index;
+			node.number = index;
 		}
 	}
-	if (node->number == 0) {
+	if (node.number == 0) {
 		expr->parameter_nr = ParamCount() + 1;
-		if (node->name && !HasNamedParameters() && ParamCount() != 0) {
+		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");
 		}
-		if (node->name) {
-			D_ASSERT(!named_param_map.count(node->name));
+		if (node.name) {
+			D_ASSERT(!named_param_map.count(node.name));
 			// Add it to the named parameter map so we can find it next time it's referenced
-			SetNamedParam(node->name, expr->parameter_nr);
+			SetNamedParam(node.name, expr->parameter_nr);
 		}
 	} else {
-		if (!node->name && HasNamedParameters()) {
+		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;
+		expr->parameter_nr = node.number;
 	}
 	SetParamCount(MaxValue<idx_t>(ParamCount(), expr->parameter_nr));
 	return std::move(expr);

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

@@ -4,12 +4,12 @@
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformPositionalReference(duckdb_libpgquery::PGPositionalReference *node) {
-	if (node->position <= 0) {
+unique_ptr<ParsedExpression> Transformer::TransformPositionalReference(duckdb_libpgquery::PGPositionalReference &node) {
+	if (node.position <= 0) {
 		throw ParserException("Positional reference node needs to be >= 1");
 	}
-	auto result = make_uniq<PositionalReferenceExpression>(node->position);
-	result->query_location = node->location;
+	auto result = make_uniq<PositionalReferenceExpression>(node.position);
+	result->query_location = node.location;
 	return std::move(result);
 }
 

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

@@ -5,15 +5,14 @@
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformSubquery(duckdb_libpgquery::PGSubLink *root) {
-	D_ASSERT(root);
+unique_ptr<ParsedExpression> Transformer::TransformSubquery(duckdb_libpgquery::PGSubLink &root) {
 	auto subquery_expr = make_uniq<SubqueryExpression>();
 
-	subquery_expr->subquery = TransformSelect(root->subselect);
+	subquery_expr->subquery = TransformSelect(root.subselect);
 	D_ASSERT(subquery_expr->subquery);
 	D_ASSERT(subquery_expr->subquery->node->GetSelectList().size() > 0);
 
-	switch (root->subLinkType) {
+	switch (root.subLinkType) {
 	case duckdb_libpgquery::PG_EXISTS_SUBLINK: {
 		subquery_expr->subquery_type = SubqueryType::EXISTS;
 		break;
@@ -22,14 +21,14 @@ unique_ptr<ParsedExpression> Transformer::TransformSubquery(duckdb_libpgquery::P
 	case duckdb_libpgquery::PG_ALL_SUBLINK: {
 		// comparison with ANY() or ALL()
 		subquery_expr->subquery_type = SubqueryType::ANY;
-		subquery_expr->child = TransformExpression(root->testexpr);
+		subquery_expr->child = TransformExpression(root.testexpr);
 		// get the operator name
-		if (!root->operName) {
+		if (!root.operName) {
 			// simple IN
 			subquery_expr->comparison_type = ExpressionType::COMPARE_EQUAL;
 		} else {
 			auto operator_name =
-			    string((reinterpret_cast<duckdb_libpgquery::PGValue *>(root->operName->head->data.ptr_value))->val.str);
+			    string((PGPointerCast<duckdb_libpgquery::PGValue>(root.operName->head->data.ptr_value))->val.str);
 			subquery_expr->comparison_type = OperatorToExpressionType(operator_name);
 		}
 		if (subquery_expr->comparison_type != ExpressionType::COMPARE_EQUAL &&
@@ -40,7 +39,7 @@ unique_ptr<ParsedExpression> Transformer::TransformSubquery(duckdb_libpgquery::P
 		    subquery_expr->comparison_type != ExpressionType::COMPARE_LESSTHANOREQUALTO) {
 			throw ParserException("ANY and ALL operators require one of =,<>,>,<,>=,<= comparisons!");
 		}
-		if (root->subLinkType == duckdb_libpgquery::PG_ALL_SUBLINK) {
+		if (root.subLinkType == duckdb_libpgquery::PG_ALL_SUBLINK) {
 			// ALL sublink is equivalent to NOT(ANY) with inverted comparison
 			// e.g. [= ALL()] is equivalent to [NOT(<> ANY())]
 			// first invert the comparison type
@@ -96,9 +95,9 @@ unique_ptr<ParsedExpression> Transformer::TransformSubquery(duckdb_libpgquery::P
 		break;
 	}
 	default:
-		throw NotImplementedException("Subquery of type %d not implemented\n", (int)root->subLinkType);
+		throw NotImplementedException("Subquery of type %d not implemented\n", (int)root.subLinkType);
 	}
-	subquery_expr->query_location = root->location;
+	subquery_expr->query_location = root.location;
 	return std::move(subquery_expr);
 }
 

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

@@ -29,50 +29,50 @@ 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) {
 	// TODO: might need to update in case of future lawsuit
-	D_ASSERT(de_with_clause);
 	stored_cte_map.push_back(&cte_map);
 
-	D_ASSERT(de_with_clause->ctes);
-	for (auto cte_ele = de_with_clause->ctes->head; cte_ele != nullptr; cte_ele = cte_ele->next) {
+	D_ASSERT(de_with_clause.ctes);
+	for (auto cte_ele = de_with_clause.ctes->head; cte_ele != nullptr; cte_ele = cte_ele->next) {
 		auto info = make_uniq<CommonTableExpressionInfo>();
 
-		auto cte = reinterpret_cast<duckdb_libpgquery::PGCommonTableExpr *>(cte_ele->data.ptr_value);
-		if (cte->aliascolnames) {
-			for (auto node = cte->aliascolnames->head; node != nullptr; node = node->next) {
+		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);
 			}
 		}
 		// lets throw some errors on unsupported features early
-		if (cte->ctecolnames) {
+		if (cte.ctecolnames) {
 			throw NotImplementedException("Column name setting not supported in CTEs");
 		}
-		if (cte->ctecoltypes) {
+		if (cte.ctecoltypes) {
 			throw NotImplementedException("Column type setting not supported in CTEs");
 		}
-		if (cte->ctecoltypmods) {
+		if (cte.ctecoltypmods) {
 			throw NotImplementedException("Column type modification not supported in CTEs");
 		}
-		if (cte->ctecolcollations) {
+		if (cte.ctecolcollations) {
 			throw NotImplementedException("CTE collations not supported");
 		}
 		// we need a query
-		if (!cte->ctequery || cte->ctequery->type != duckdb_libpgquery::T_PGSelectStmt) {
+		if (!cte.ctequery || cte.ctequery->type != duckdb_libpgquery::T_PGSelectStmt) {
 			throw NotImplementedException("A CTE needs a SELECT");
 		}
 
 		// CTE transformation can either result in inlining for non recursive CTEs, or in recursive CTE bindings
 		// otherwise.
-		if (cte->cterecursive || de_with_clause->recursive) {
+		if (cte.cterecursive || de_with_clause.recursive) {
 			info->query = TransformRecursiveCTE(cte, *info);
 		} else {
 			Transformer cte_transformer(*this);
-			info->query = cte_transformer.TransformSelect(cte->ctequery);
+			info->query =
+			    cte_transformer.TransformSelect(*PGPointerCast<duckdb_libpgquery::PGSelectStmt>(cte.ctequery));
 		}
 		D_ASSERT(info->query);
-		auto cte_name = string(cte->ctename);
+		auto cte_name = string(cte.ctename);
 
 		auto it = cte_map.map.find(cte_name);
 		if (it != cte_map.map.end()) {
@@ -83,41 +83,37 @@ void Transformer::TransformCTE(duckdb_libpgquery::PGWithClause *de_with_clause,
 	}
 }
 
-unique_ptr<SelectStatement> Transformer::TransformRecursiveCTE(duckdb_libpgquery::PGCommonTableExpr *cte,
+unique_ptr<SelectStatement> Transformer::TransformRecursiveCTE(duckdb_libpgquery::PGCommonTableExpr &cte,
                                                                CommonTableExpressionInfo &info) {
-	auto stmt = (duckdb_libpgquery::PGSelectStmt *)cte->ctequery;
+	auto &stmt = *PGPointerCast<duckdb_libpgquery::PGSelectStmt>(cte.ctequery);
 
 	unique_ptr<SelectStatement> select;
-	switch (stmt->op) {
+	switch (stmt.op) {
 	case duckdb_libpgquery::PG_SETOP_UNION:
 	case duckdb_libpgquery::PG_SETOP_EXCEPT:
 	case duckdb_libpgquery::PG_SETOP_INTERSECT: {
 		select = make_uniq<SelectStatement>();
 		select->node = make_uniq_base<QueryNode, RecursiveCTENode>();
-		auto result = (RecursiveCTENode *)select->node.get();
-		result->ctename = string(cte->ctename);
-		result->union_all = stmt->all;
-		result->left = TransformSelectNode(stmt->larg);
-		result->right = TransformSelectNode(stmt->rarg);
-		result->aliases = info.aliases;
-
-		D_ASSERT(result->left);
-		D_ASSERT(result->right);
-
-		if (stmt->op != duckdb_libpgquery::PG_SETOP_UNION) {
+		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");
 		}
 		break;
 	}
 	default:
 		// This CTE is not recursive. Fallback to regular query transformation.
-		return TransformSelect(cte->ctequery);
+		return TransformSelect(*PGPointerCast<duckdb_libpgquery::PGSelectStmt>(cte.ctequery));
 	}
 
-	if (stmt->limitCount || stmt->limitOffset) {
+	if (stmt.limitCount || stmt.limitOffset) {
 		throw ParserException("LIMIT or OFFSET in a recursive query is not allowed");
 	}
-	if (stmt->sortClause) {
+	if (stmt.sortClause) {
 		throw ParserException("ORDER BY in a recursive query is not allowed");
 	}
 	return select;

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

@@ -72,7 +72,7 @@ static void AddCubeSets(const GroupingSet &current_set, vector<GroupingSet> &res
 	}
 }
 
-void Transformer::TransformGroupByExpression(duckdb_libpgquery::PGNode *n, GroupingExpressionMap &map,
+void Transformer::TransformGroupByExpression(duckdb_libpgquery::PGNode &n, GroupingExpressionMap &map,
                                              GroupByNode &result, vector<idx_t> &indexes) {
 	auto expression = TransformExpression(n);
 	AddGroupByExpression(std::move(expression), map, result, indexes);
@@ -80,11 +80,11 @@ void Transformer::TransformGroupByExpression(duckdb_libpgquery::PGNode *n, Group
 
 // If one GROUPING SETS clause is nested inside another,
 // the effect is the same as if all the elements of the inner clause had been written directly in the outer clause.
-void Transformer::TransformGroupByNode(duckdb_libpgquery::PGNode *n, GroupingExpressionMap &map, SelectNode &result,
+void Transformer::TransformGroupByNode(duckdb_libpgquery::PGNode &n, GroupingExpressionMap &map, SelectNode &result,
                                        vector<GroupingSet> &result_sets) {
-	if (n->type == duckdb_libpgquery::T_PGGroupingSet) {
-		auto grouping_set = (duckdb_libpgquery::PGGroupingSet *)n;
-		switch (grouping_set->kind) {
+	if (n.type == duckdb_libpgquery::T_PGGroupingSet) {
+		auto &grouping_set = PGCast<duckdb_libpgquery::PGGroupingSet>(n);
+		switch (grouping_set.kind) {
 		case duckdb_libpgquery::GROUPING_SET_EMPTY:
 			result_sets.emplace_back();
 			break;
@@ -93,18 +93,18 @@ void Transformer::TransformGroupByNode(duckdb_libpgquery::PGNode *n, GroupingExp
 			break;
 		}
 		case duckdb_libpgquery::GROUPING_SET_SETS: {
-			for (auto node = grouping_set->content->head; node; node = node->next) {
-				auto pg_node = (duckdb_libpgquery::PGNode *)node->data.ptr_value;
-				TransformGroupByNode(pg_node, map, result, result_sets);
+			for (auto node = grouping_set.content->head; node; node = node->next) {
+				auto pg_node = PGPointerCast<duckdb_libpgquery::PGNode>(node->data.ptr_value);
+				TransformGroupByNode(*pg_node, map, result, result_sets);
 			}
 			break;
 		}
 		case duckdb_libpgquery::GROUPING_SET_ROLLUP: {
 			vector<GroupingSet> rollup_sets;
-			for (auto node = grouping_set->content->head; node; node = node->next) {
-				auto pg_node = (duckdb_libpgquery::PGNode *)node->data.ptr_value;
+			for (auto node = grouping_set.content->head; node; node = node->next) {
+				auto pg_node = PGPointerCast<duckdb_libpgquery::PGNode>(node->data.ptr_value);
 				vector<idx_t> rollup_set;
-				TransformGroupByExpression(pg_node, map, result.groups, rollup_set);
+				TransformGroupByExpression(*pg_node, map, result.groups, rollup_set);
 				rollup_sets.push_back(VectorToGroupingSet(rollup_set));
 			}
 			// generate the subsets of the rollup set and add them to the grouping sets
@@ -118,10 +118,10 @@ void Transformer::TransformGroupByNode(duckdb_libpgquery::PGNode *n, GroupingExp
 		}
 		case duckdb_libpgquery::GROUPING_SET_CUBE: {
 			vector<GroupingSet> cube_sets;
-			for (auto node = grouping_set->content->head; node; node = node->next) {
-				auto pg_node = (duckdb_libpgquery::PGNode *)node->data.ptr_value;
+			for (auto node = grouping_set.content->head; node; node = node->next) {
+				auto pg_node = PGPointerCast<duckdb_libpgquery::PGNode>(node->data.ptr_value);
 				vector<idx_t> cube_set;
-				TransformGroupByExpression(pg_node, map, result.groups, cube_set);
+				TransformGroupByExpression(*pg_node, map, result.groups, cube_set);
 				cube_sets.push_back(VectorToGroupingSet(cube_set));
 			}
 			// generate the subsets of the rollup set and add them to the grouping sets
@@ -132,7 +132,7 @@ void Transformer::TransformGroupByNode(duckdb_libpgquery::PGNode *n, GroupingExp
 			break;
 		}
 		default:
-			throw InternalException("Unsupported GROUPING SET type %d", grouping_set->kind);
+			throw InternalException("Unsupported GROUPING SET type %d", grouping_set.kind);
 		}
 	} else {
 		vector<idx_t> indexes;
@@ -143,16 +143,16 @@ void Transformer::TransformGroupByNode(duckdb_libpgquery::PGNode *n, GroupingExp
 
 // If multiple grouping items are specified in a single GROUP BY clause,
 // then the final list of grouping sets is the cross product of the individual items.
-bool Transformer::TransformGroupBy(duckdb_libpgquery::PGList *group, SelectNode &select_node) {
+bool Transformer::TransformGroupBy(optional_ptr<duckdb_libpgquery::PGList> group, SelectNode &select_node) {
 	if (!group) {
 		return false;
 	}
 	auto &result = select_node.groups;
 	GroupingExpressionMap map;
 	for (auto node = group->head; node != nullptr; node = node->next) {
-		auto n = reinterpret_cast<duckdb_libpgquery::PGNode *>(node->data.ptr_value);
+		auto n = PGPointerCast<duckdb_libpgquery::PGNode>(node->data.ptr_value);
 		vector<GroupingSet> result_sets;
-		TransformGroupByNode(n, map, select_node, result_sets);
+		TransformGroupByNode(*n, map, select_node, result_sets);
 		CheckGroupingSetMax(result_sets.size());
 		if (result.grouping_sets.empty()) {
 			// no grouping sets yet: use the current set of grouping sets

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

@@ -18,13 +18,13 @@ static SampleMethod GetSampleMethod(const string &method) {
 	}
 }
 
-unique_ptr<SampleOptions> Transformer::TransformSampleOptions(duckdb_libpgquery::PGNode *options) {
+unique_ptr<SampleOptions> Transformer::TransformSampleOptions(optional_ptr<duckdb_libpgquery::PGNode> options) {
 	if (!options) {
 		return nullptr;
 	}
 	auto result = make_uniq<SampleOptions>();
-	auto &sample_options = (duckdb_libpgquery::PGSampleOptions &)*options;
-	auto &sample_size = (duckdb_libpgquery::PGSampleSize &)*sample_options.sample_size;
+	auto &sample_options = PGCast<duckdb_libpgquery::PGSampleOptions>(*options);
+	auto &sample_size = *PGPointerCast<duckdb_libpgquery::PGSampleSize>(sample_options.sample_size);
 	auto sample_value = TransformValue(sample_size.sample_size)->value;
 	result->is_percentage = sample_size.is_percentage;
 	if (sample_size.is_percentage) {

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

@@ -7,13 +7,13 @@
 
 namespace duckdb {
 
-LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName *type_name) {
-	if (!type_name || type_name->type != duckdb_libpgquery::T_PGTypeName) {
+LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName &type_name) {
+	if (type_name.type != duckdb_libpgquery::T_PGTypeName) {
 		throw ParserException("Expected a type");
 	}
 	auto stack_checker = StackCheck();
 
-	auto name = (reinterpret_cast<duckdb_libpgquery::PGValue *>(type_name->names->tail->data.ptr_value)->val.str);
+	auto name = PGPointerCast<duckdb_libpgquery::PGValue>(type_name.names->tail->data.ptr_value)->val.str;
 	// transform it to the SQL type
 	LogicalTypeId base_type = TransformStringToLogicalTypeId(name);
 
@@ -23,21 +23,21 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName *type_n
 	} else if (base_type == LogicalTypeId::ENUM) {
 		throw ParserException("ENUM is not valid as a stand-alone type");
 	} else if (base_type == LogicalTypeId::STRUCT) {
-		if (!type_name->typmods || type_name->typmods->length == 0) {
+		if (!type_name.typmods || type_name.typmods->length == 0) {
 			throw ParserException("Struct needs a name and entries");
 		}
 		child_list_t<LogicalType> children;
 		case_insensitive_set_t name_collision_set;
 
-		for (auto node = type_name->typmods->head; node; node = node->next) {
-			auto &type_val = *((duckdb_libpgquery::PGList *)node->data.ptr_value);
+		for (auto node = type_name.typmods->head; node; node = node->next) {
+			auto &type_val = *PGPointerCast<duckdb_libpgquery::PGList>(node->data.ptr_value);
 			if (type_val.length != 2) {
 				throw ParserException("Struct entry needs an entry name and a type name");
 			}
 
-			auto entry_name_node = (duckdb_libpgquery::PGValue *)(type_val.head->data.ptr_value);
+			auto entry_name_node = PGPointerCast<duckdb_libpgquery::PGValue>(type_val.head->data.ptr_value);
 			D_ASSERT(entry_name_node->type == duckdb_libpgquery::T_PGString);
-			auto entry_type_node = (duckdb_libpgquery::PGValue *)(type_val.tail->data.ptr_value);
+			auto entry_type_node = PGPointerCast<duckdb_libpgquery::PGTypeName>(type_val.tail->data.ptr_value);
 			D_ASSERT(entry_type_node->type == duckdb_libpgquery::T_PGTypeName);
 
 			auto entry_name = string(entry_name_node->val.str);
@@ -47,42 +47,43 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName *type_n
 				throw ParserException("Duplicate struct entry name \"%s\"", entry_name);
 			}
 			name_collision_set.insert(entry_name);
+			auto entry_type = TransformTypeName(*entry_type_node);
 
-			auto entry_type = TransformTypeName((duckdb_libpgquery::PGTypeName *)entry_type_node);
 			children.push_back(make_pair(entry_name, entry_type));
 		}
 		D_ASSERT(!children.empty());
 		result_type = LogicalType::STRUCT(children);
 
 	} else if (base_type == LogicalTypeId::MAP) {
-
-		if (!type_name->typmods || type_name->typmods->length != 2) {
+		if (!type_name.typmods || type_name.typmods->length != 2) {
 			throw ParserException("Map type needs exactly two entries, key and value type");
 		}
-		auto key_type = TransformTypeName((duckdb_libpgquery::PGTypeName *)type_name->typmods->head->data.ptr_value);
-		auto value_type = TransformTypeName((duckdb_libpgquery::PGTypeName *)type_name->typmods->tail->data.ptr_value);
+		auto key_type =
+		    TransformTypeName(*PGPointerCast<duckdb_libpgquery::PGTypeName>(type_name.typmods->head->data.ptr_value));
+		auto value_type =
+		    TransformTypeName(*PGPointerCast<duckdb_libpgquery::PGTypeName>(type_name.typmods->tail->data.ptr_value));
 
 		result_type = LogicalType::MAP(std::move(key_type), std::move(value_type));
 	} else if (base_type == LogicalTypeId::UNION) {
-		if (!type_name->typmods || type_name->typmods->length == 0) {
+		if (!type_name.typmods || type_name.typmods->length == 0) {
 			throw ParserException("Union type needs at least one member");
 		}
-		if (type_name->typmods->length > (int)UnionType::MAX_UNION_MEMBERS) {
+		if (type_name.typmods->length > (int)UnionType::MAX_UNION_MEMBERS) {
 			throw ParserException("Union types can have at most %d members", UnionType::MAX_UNION_MEMBERS);
 		}
 
 		child_list_t<LogicalType> children;
 		case_insensitive_set_t name_collision_set;
 
-		for (auto node = type_name->typmods->head; node; node = node->next) {
-			auto &type_val = *((duckdb_libpgquery::PGList *)node->data.ptr_value);
+		for (auto node = type_name.typmods->head; node; node = node->next) {
+			auto &type_val = *PGPointerCast<duckdb_libpgquery::PGList>(node->data.ptr_value);
 			if (type_val.length != 2) {
 				throw ParserException("Union type member needs a tag name and a type name");
 			}
 
-			auto entry_name_node = (duckdb_libpgquery::PGValue *)(type_val.head->data.ptr_value);
+			auto entry_name_node = PGPointerCast<duckdb_libpgquery::PGValue>(type_val.head->data.ptr_value);
 			D_ASSERT(entry_name_node->type == duckdb_libpgquery::T_PGString);
-			auto entry_type_node = (duckdb_libpgquery::PGValue *)(type_val.tail->data.ptr_value);
+			auto entry_type_node = PGPointerCast<duckdb_libpgquery::PGTypeName>(type_val.tail->data.ptr_value);
 			D_ASSERT(entry_type_node->type == duckdb_libpgquery::T_PGTypeName);
 
 			auto entry_name = string(entry_name_node->val.str);
@@ -94,7 +95,7 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName *type_n
 
 			name_collision_set.insert(entry_name);
 
-			auto entry_type = TransformTypeName((duckdb_libpgquery::PGTypeName *)entry_type_node);
+			auto entry_type = TransformTypeName(*entry_type_node);
 			children.push_back(make_pair(entry_name, entry_type));
 		}
 		D_ASSERT(!children.empty());
@@ -111,9 +112,9 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName *type_n
 		}
 		// check any modifiers
 		int modifier_idx = 0;
-		if (type_name->typmods) {
-			for (auto node = type_name->typmods->head; node; node = node->next) {
-				auto &const_val = *((duckdb_libpgquery::PGAConst *)node->data.ptr_value);
+		if (type_name.typmods) {
+			for (auto node = type_name.typmods->head; node; node = node->next) {
+				auto &const_val = *PGPointerCast<duckdb_libpgquery::PGAConst>(node->data.ptr_value);
 				if (const_val.type != duckdb_libpgquery::T_PGAConst ||
 				    const_val.val.type != duckdb_libpgquery::T_PGInteger) {
 					throw ParserException("Expected an integer constant as type modifier");
@@ -169,7 +170,7 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName *type_n
 			break;
 		}
 		case LogicalTypeId::BIT: {
-			if (!width && type_name->typmods) {
+			if (!width && type_name.typmods) {
 				throw ParserException("Type %s does not support any modifiers!", LogicalType(base_type).ToString());
 			}
 			result_type = LogicalType(base_type);
@@ -204,10 +205,10 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName *type_n
 			break;
 		}
 	}
-	if (type_name->arrayBounds) {
+	if (type_name.arrayBounds) {
 		// array bounds: turn the type into a list
 		idx_t extra_stack = 0;
-		for (auto cell = type_name->arrayBounds->head; cell != nullptr; cell = cell->next) {
+		for (auto cell = type_name.arrayBounds->head; cell != nullptr; cell = cell->next) {
 			result_type = LogicalType::LIST(result_type);
 			StackCheck(extra_stack++);
 		}