duckdb 0.8.1-dev65.0 → 0.8.1

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/nodetype_to_string.cpp

@@ -816,8 +816,6 @@ std::string Transformer::NodetypeToString(duckdb_libpgquery::PGNodeTag type) { /
 		return "T_PGAttachStmt";
 	case duckdb_libpgquery::T_PGUseStmt:
 		return "T_PGUseStmt";
-	case duckdb_libpgquery::T_PGCreateDatabaseStmt:
-		return "T_PGCreateDatabaseStmt";
 	default:
 		return "(UNKNOWN)";
 	}

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

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

@@ -7,24 +7,22 @@
 
 namespace duckdb {
 
-unique_ptr<AlterStatement> Transformer::TransformAlterSequence(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGAlterSeqStmt *>(node);
-	D_ASSERT(stmt);
+unique_ptr<AlterStatement> Transformer::TransformAlterSequence(duckdb_libpgquery::PGAlterSeqStmt &stmt) {
 	auto result = make_uniq<AlterStatement>();
 
-	auto qname = TransformQualifiedName(stmt->sequence);
+	auto qname = TransformQualifiedName(*stmt.sequence);
 	auto sequence_catalog = qname.catalog;
 	auto sequence_schema = qname.schema;
 	auto sequence_name = qname.name;
 
-	if (!stmt->options) {
+	if (!stmt.options) {
 		throw InternalException("Expected an argument for ALTER SEQUENCE.");
 	}
 
 	unordered_set<SequenceInfo, EnumClassHash> used;
-	duckdb_libpgquery::PGListCell *cell = nullptr;
-	for_each_cell(cell, stmt->options->head) {
-		auto *def_elem = reinterpret_cast<duckdb_libpgquery::PGDefElem *>(cell->data.ptr_value);
+	duckdb_libpgquery::PGListCell *cell;
+	for_each_cell(cell, stmt.options->head) {
+		auto def_elem = PGPointerCast<duckdb_libpgquery::PGDefElem>(cell->data.ptr_value);
 		string opt_name = string(def_elem->defname);
 
 		if (opt_name == "owned_by") {
@@ -33,7 +31,7 @@ unique_ptr<AlterStatement> Transformer::TransformAlterSequence(duckdb_libpgquery
 			}
 			used.insert(SequenceInfo::SEQ_OWN);
 
-			auto val = (duckdb_libpgquery::PGValue *)def_elem->arg;
+			auto val = PGPointerCast<duckdb_libpgquery::PGList>(def_elem->arg);
 			if (!val) {
 				throw InternalException("Expected an argument for option %s", opt_name);
 			}
@@ -43,9 +41,8 @@ unique_ptr<AlterStatement> Transformer::TransformAlterSequence(duckdb_libpgquery
 			}
 			auto opt_values = vector<string>();
 
-			auto opt_value_list = (duckdb_libpgquery::PGList *)(val);
-			for (auto c = opt_value_list->head; c != nullptr; c = lnext(c)) {
-				auto target = (duckdb_libpgquery::PGResTarget *)(c->data.ptr_value);
+			for (auto c = val->head; c != nullptr; c = lnext(c)) {
+				auto target = PGPointerCast<duckdb_libpgquery::PGResTarget>(c->data.ptr_value);
 				opt_values.emplace_back(target->name);
 			}
 			D_ASSERT(!opt_values.empty());
@@ -62,13 +59,13 @@ unique_ptr<AlterStatement> Transformer::TransformAlterSequence(duckdb_libpgquery
 			}
 			auto info = make_uniq<ChangeOwnershipInfo>(CatalogType::SEQUENCE_ENTRY, sequence_catalog, sequence_schema,
 			                                           sequence_name, owner_schema, owner_name,
-			                                           TransformOnEntryNotFound(stmt->missing_ok));
+			                                           TransformOnEntryNotFound(stmt.missing_ok));
 			result->info = std::move(info);
 		} else {
 			throw NotImplementedException("ALTER SEQUENCE option not supported yet!");
 		}
 	}
-	result->info->if_not_found = TransformOnEntryNotFound(stmt->missing_ok);
+	result->info->if_not_found = TransformOnEntryNotFound(stmt.missing_ok);
 	return result;
 }
 } // namespace duckdb

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

@@ -10,34 +10,32 @@ OnEntryNotFound Transformer::TransformOnEntryNotFound(bool missing_ok) {
 	return missing_ok ? OnEntryNotFound::RETURN_NULL : OnEntryNotFound::THROW_EXCEPTION;
 }
 
-unique_ptr<AlterStatement> Transformer::TransformAlter(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGAlterTableStmt *>(node);
-	D_ASSERT(stmt);
-	D_ASSERT(stmt->relation);
+unique_ptr<AlterStatement> Transformer::TransformAlter(duckdb_libpgquery::PGAlterTableStmt &stmt) {
+	D_ASSERT(stmt.relation);
 
-	if (stmt->cmds->length != 1) {
+	if (stmt.cmds->length != 1) {
 		throw ParserException("Only one ALTER command per statement is supported");
 	}
 
 	auto result = make_uniq<AlterStatement>();
-	auto qname = TransformQualifiedName(stmt->relation);
+	auto qname = TransformQualifiedName(*stmt.relation);
 
 	// first we check the type of ALTER
-	for (auto c = stmt->cmds->head; c != nullptr; c = c->next) {
+	for (auto c = stmt.cmds->head; c != nullptr; c = c->next) {
 		auto command = reinterpret_cast<duckdb_libpgquery::PGAlterTableCmd *>(lfirst(c));
-		AlterEntryData data(qname.catalog, qname.schema, qname.name, TransformOnEntryNotFound(stmt->missing_ok));
+		AlterEntryData data(qname.catalog, qname.schema, qname.name, TransformOnEntryNotFound(stmt.missing_ok));
 		// TODO: Include more options for command->subtype
 		switch (command->subtype) {
 		case duckdb_libpgquery::PG_AT_AddColumn: {
-			auto cdef = (duckdb_libpgquery::PGColumnDef *)command->def;
+			auto cdef = PGPointerCast<duckdb_libpgquery::PGColumnDef>(command->def);
 
-			if (stmt->relkind != duckdb_libpgquery::PG_OBJECT_TABLE) {
+			if (stmt.relkind != duckdb_libpgquery::PG_OBJECT_TABLE) {
 				throw ParserException("Adding columns is only supported for tables");
 			}
 			if (cdef->category == duckdb_libpgquery::COL_GENERATED) {
 				throw ParserException("Adding generated columns after table creation is not supported yet");
 			}
-			auto centry = TransformColumnDefinition(cdef);
+			auto centry = TransformColumnDefinition(*cdef);
 
 			if (cdef->constraints) {
 				for (auto constr = cdef->constraints->head; constr != nullptr; constr = constr->next) {
@@ -54,7 +52,7 @@ unique_ptr<AlterStatement> Transformer::TransformAlter(duckdb_libpgquery::PGNode
 		case duckdb_libpgquery::PG_AT_DropColumn: {
 			bool cascade = command->behavior == duckdb_libpgquery::PG_DROP_CASCADE;
 
-			if (stmt->relkind != duckdb_libpgquery::PG_OBJECT_TABLE) {
+			if (stmt.relkind != duckdb_libpgquery::PG_OBJECT_TABLE) {
 				throw ParserException("Dropping columns is only supported for tables");
 			}
 			result->info = make_uniq<RemoveColumnInfo>(std::move(data), command->name, command->missing_ok, cascade);
@@ -63,18 +61,18 @@ unique_ptr<AlterStatement> Transformer::TransformAlter(duckdb_libpgquery::PGNode
 		case duckdb_libpgquery::PG_AT_ColumnDefault: {
 			auto expr = TransformExpression(command->def);
 
-			if (stmt->relkind != duckdb_libpgquery::PG_OBJECT_TABLE) {
+			if (stmt.relkind != duckdb_libpgquery::PG_OBJECT_TABLE) {
 				throw ParserException("Alter column's default is only supported for tables");
 			}
 			result->info = make_uniq<SetDefaultInfo>(std::move(data), command->name, std::move(expr));
 			break;
 		}
 		case duckdb_libpgquery::PG_AT_AlterColumnType: {
-			auto cdef = (duckdb_libpgquery::PGColumnDef *)command->def;
-			auto column_definition = TransformColumnDefinition(cdef);
+			auto cdef = PGPointerCast<duckdb_libpgquery::PGColumnDef>(command->def);
+			auto column_definition = TransformColumnDefinition(*cdef);
 			unique_ptr<ParsedExpression> expr;
 
-			if (stmt->relkind != duckdb_libpgquery::PG_OBJECT_TABLE) {
+			if (stmt.relkind != duckdb_libpgquery::PG_OBJECT_TABLE) {
 				throw ParserException("Alter column's type is only supported for tables");
 			}
 			if (cdef->raw_default) {

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

@@ -5,20 +5,19 @@
 
 namespace duckdb {
 
-unique_ptr<AttachStatement> Transformer::TransformAttach(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGAttachStmt *>(node);
+unique_ptr<AttachStatement> Transformer::TransformAttach(duckdb_libpgquery::PGAttachStmt &stmt) {
 	auto result = make_uniq<AttachStatement>();
 	auto info = make_uniq<AttachInfo>();
-	info->name = stmt->name ? stmt->name : string();
-	info->path = stmt->path;
+	info->name = stmt.name ? stmt.name : string();
+	info->path = stmt.path;
 
-	if (stmt->options) {
-		duckdb_libpgquery::PGListCell *cell = nullptr;
-		for_each_cell(cell, stmt->options->head) {
-			auto *def_elem = reinterpret_cast<duckdb_libpgquery::PGDefElem *>(cell->data.ptr_value);
+	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(*((duckdb_libpgquery::PGValue *)def_elem->arg))->value;
+				val = TransformValue(*PGPointerCast<duckdb_libpgquery::PGValue>(def_elem->arg))->value;
 			} else {
 				val = Value::BOOLEAN(true);
 			}

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

@@ -3,12 +3,9 @@
 
 namespace duckdb {
 
-unique_ptr<CallStatement> Transformer::TransformCall(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGCallStmt *>(node);
-	D_ASSERT(stmt);
-
+unique_ptr<CallStatement> Transformer::TransformCall(duckdb_libpgquery::PGCallStmt &stmt) {
 	auto result = make_uniq<CallStatement>();
-	result->function = TransformFuncCall((duckdb_libpgquery::PGFuncCall *)stmt->func);
+	result->function = TransformFuncCall(*PGPointerCast<duckdb_libpgquery::PGFuncCall>(stmt.func));
 	return result;
 }