duckdb 0.8.1-dev26.0 → 0.8.1-dev276.0

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

@@ -21,7 +21,7 @@ void Transformer::TransformModifiers(duckdb_libpgquery::PGSelectStmt &stmt, Quer
 	if (stmt.limitCount || stmt.limitOffset) {
 		if (stmt.limitCount && stmt.limitCount->type == duckdb_libpgquery::T_PGLimitPercent) {
 			auto limit_percent_modifier = make_uniq<LimitPercentModifier>();
-			auto expr_node = reinterpret_cast<duckdb_libpgquery::PGLimitPercent *>(stmt.limitCount)->limit_percent;
+			auto expr_node = PGPointerCast<duckdb_libpgquery::PGLimitPercent>(stmt.limitCount)->limit_percent;
 			limit_percent_modifier->limit = TransformExpression(expr_node);
 			if (stmt.limitOffset) {
 				limit_percent_modifier->offset = TransformExpression(stmt.limitOffset);
@@ -40,22 +40,22 @@ void Transformer::TransformModifiers(duckdb_libpgquery::PGSelectStmt &stmt, Quer
 	}
 }
 
-unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PGSelectStmt *stmt) {
-	D_ASSERT(stmt->type == duckdb_libpgquery::T_PGSelectStmt);
+unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PGSelectStmt &stmt) {
+	D_ASSERT(stmt.type == duckdb_libpgquery::T_PGSelectStmt);
 	auto stack_checker = StackCheck();
 
 	unique_ptr<QueryNode> node;
 
-	switch (stmt->op) {
+	switch (stmt.op) {
 	case duckdb_libpgquery::PG_SETOP_NONE: {
 		node = make_uniq<SelectNode>();
 		auto &result = node->Cast<SelectNode>();
-		if (stmt->withClause) {
-			TransformCTE(reinterpret_cast<duckdb_libpgquery::PGWithClause *>(stmt->withClause), node->cte_map);
+		if (stmt.withClause) {
+			TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause), node->cte_map);
 		}
-		if (stmt->windowClause) {
-			for (auto window_ele = stmt->windowClause->head; window_ele != nullptr; window_ele = window_ele->next) {
-				auto window_def = reinterpret_cast<duckdb_libpgquery::PGWindowDef *>(window_ele->data.ptr_value);
+		if (stmt.windowClause) {
+			for (auto window_ele = stmt.windowClause->head; window_ele != nullptr; window_ele = window_ele->next) {
+				auto window_def = PGPointerCast<duckdb_libpgquery::PGWindowDef>(window_ele->data.ptr_value);
 				D_ASSERT(window_def);
 				D_ASSERT(window_def->name);
 				string window_name(window_def->name);
@@ -63,47 +63,47 @@ unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PG
 				if (it != window_clauses.end()) {
 					throw ParserException("window \"%s\" is already defined", window_name);
 				}
-				window_clauses[window_name] = window_def;
+				window_clauses[window_name] = window_def.get();
 			}
 		}
 
 		// checks distinct clause
-		if (stmt->distinctClause != nullptr) {
+		if (stmt.distinctClause != nullptr) {
 			auto modifier = make_uniq<DistinctModifier>();
 			// checks distinct on clause
-			auto target = reinterpret_cast<duckdb_libpgquery::PGNode *>(stmt->distinctClause->head->data.ptr_value);
+			auto target = PGPointerCast<duckdb_libpgquery::PGNode>(stmt.distinctClause->head->data.ptr_value);
 			if (target) {
 				//  add the columns defined in the ON clause to the select list
-				TransformExpressionList(*stmt->distinctClause, modifier->distinct_on_targets);
+				TransformExpressionList(*stmt.distinctClause, modifier->distinct_on_targets);
 			}
 			result.modifiers.push_back(std::move(modifier));
 		}
 
 		// do this early so the value lists also have a `FROM`
-		if (stmt->valuesLists) {
+		if (stmt.valuesLists) {
 			// VALUES list, create an ExpressionList
-			D_ASSERT(!stmt->fromClause);
-			result.from_table = TransformValuesList(stmt->valuesLists);
+			D_ASSERT(!stmt.fromClause);
+			result.from_table = TransformValuesList(stmt.valuesLists);
 			result.select_list.push_back(make_uniq<StarExpression>());
 		} else {
-			if (!stmt->targetList) {
+			if (!stmt.targetList) {
 				throw ParserException("SELECT clause without selection list");
 			}
 			// select list
-			TransformExpressionList(*stmt->targetList, result.select_list);
-			result.from_table = TransformFrom(stmt->fromClause);
+			TransformExpressionList(*stmt.targetList, result.select_list);
+			result.from_table = TransformFrom(stmt.fromClause);
 		}
 
 		// where
-		result.where_clause = TransformExpression(stmt->whereClause);
+		result.where_clause = TransformExpression(stmt.whereClause);
 		// group by
-		TransformGroupBy(stmt->groupClause, result);
+		TransformGroupBy(stmt.groupClause, result);
 		// having
-		result.having = TransformExpression(stmt->havingClause);
+		result.having = TransformExpression(stmt.havingClause);
 		// qualify
-		result.qualify = TransformExpression(stmt->qualifyClause);
+		result.qualify = TransformExpression(stmt.qualifyClause);
 		// sample
-		result.sample = TransformSampleOptions(stmt->sampleOptions);
+		result.sample = TransformSampleOptions(stmt.sampleOptions);
 		break;
 	}
 	case duckdb_libpgquery::PG_SETOP_UNION:
@@ -112,19 +112,19 @@ unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PG
 	case duckdb_libpgquery::PG_SETOP_UNION_BY_NAME: {
 		node = make_uniq<SetOperationNode>();
 		auto &result = node->Cast<SetOperationNode>();
-		if (stmt->withClause) {
-			TransformCTE(reinterpret_cast<duckdb_libpgquery::PGWithClause *>(stmt->withClause), node->cte_map);
+		if (stmt.withClause) {
+			TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause), node->cte_map);
 		}
-		result.left = TransformSelectNode(stmt->larg);
-		result.right = TransformSelectNode(stmt->rarg);
+		result.left = TransformSelectNode(*stmt.larg);
+		result.right = TransformSelectNode(*stmt.rarg);
 		if (!result.left || !result.right) {
 			throw Exception("Failed to transform setop children.");
 		}
 
 		bool select_distinct = true;
-		switch (stmt->op) {
+		switch (stmt.op) {
 		case duckdb_libpgquery::PG_SETOP_UNION:
-			select_distinct = !stmt->all;
+			select_distinct = !stmt.all;
 			result.setop_type = SetOperationType::UNION;
 			break;
 		case duckdb_libpgquery::PG_SETOP_EXCEPT:
@@ -134,7 +134,7 @@ unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PG
 			result.setop_type = SetOperationType::INTERSECT;
 			break;
 		case duckdb_libpgquery::PG_SETOP_UNION_BY_NAME:
-			select_distinct = !stmt->all;
+			select_distinct = !stmt.all;
 			result.setop_type = SetOperationType::UNION_BY_NAME;
 			break;
 		default:
@@ -143,15 +143,15 @@ unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PG
 		if (select_distinct) {
 			result.modifiers.push_back(make_uniq<DistinctModifier>());
 		}
-		if (stmt->sampleOptions) {
+		if (stmt.sampleOptions) {
 			throw ParserException("SAMPLE clause is only allowed in regular SELECT statements");
 		}
 		break;
 	}
 	default:
-		throw NotImplementedException("Statement type %d not implemented!", stmt->op);
+		throw NotImplementedException("Statement type %d not implemented!", stmt.op);
 	}
-	TransformModifiers(*stmt, *node);
+	TransformModifiers(stmt, *node);
 	return node;
 }
 

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

@@ -35,44 +35,43 @@ SetType ToSetType(duckdb_libpgquery::VariableSetKind pg_kind) {
 
 } // namespace
 
-unique_ptr<SetStatement> Transformer::TransformSetVariable(duckdb_libpgquery::PGVariableSetStmt *stmt) {
-	D_ASSERT(stmt->kind == duckdb_libpgquery::VariableSetKind::VAR_SET_VALUE);
+unique_ptr<SetStatement> Transformer::TransformSetVariable(duckdb_libpgquery::PGVariableSetStmt &stmt) {
+	D_ASSERT(stmt.kind == duckdb_libpgquery::VariableSetKind::VAR_SET_VALUE);
 
-	if (stmt->scope == duckdb_libpgquery::VariableSetScope::VAR_SET_SCOPE_LOCAL) {
+	if (stmt.scope == duckdb_libpgquery::VariableSetScope::VAR_SET_SCOPE_LOCAL) {
 		throw NotImplementedException("SET LOCAL is not implemented.");
 	}
 
-	auto name = std::string(stmt->name);
+	auto name = std::string(stmt.name);
 	D_ASSERT(!name.empty()); // parser protect us!
-	if (stmt->args->length != 1) {
+	if (stmt.args->length != 1) {
 		throw ParserException("SET needs a single scalar value parameter");
 	}
-	D_ASSERT(stmt->args->head && stmt->args->head->data.ptr_value);
-	D_ASSERT(((duckdb_libpgquery::PGNode *)stmt->args->head->data.ptr_value)->type == duckdb_libpgquery::T_PGAConst);
+	D_ASSERT(stmt.args->head && stmt.args->head->data.ptr_value);
+	auto const_val = PGPointerCast<duckdb_libpgquery::PGAConst>(stmt.args->head->data.ptr_value);
+	D_ASSERT(const_val->type == duckdb_libpgquery::T_PGAConst);
 
-	auto value = TransformValue(((duckdb_libpgquery::PGAConst *)stmt->args->head->data.ptr_value)->val)->value;
-
-	return make_uniq<SetVariableStatement>(name, value, ToSetScope(stmt->scope));
+	auto value = TransformValue(const_val->val)->value;
+	return make_uniq<SetVariableStatement>(name, value, ToSetScope(stmt.scope));
 }
 
-unique_ptr<SetStatement> Transformer::TransformResetVariable(duckdb_libpgquery::PGVariableSetStmt *stmt) {
-	D_ASSERT(stmt->kind == duckdb_libpgquery::VariableSetKind::VAR_RESET);
+unique_ptr<SetStatement> Transformer::TransformResetVariable(duckdb_libpgquery::PGVariableSetStmt &stmt) {
+	D_ASSERT(stmt.kind == duckdb_libpgquery::VariableSetKind::VAR_RESET);
 
-	if (stmt->scope == duckdb_libpgquery::VariableSetScope::VAR_SET_SCOPE_LOCAL) {
+	if (stmt.scope == duckdb_libpgquery::VariableSetScope::VAR_SET_SCOPE_LOCAL) {
 		throw NotImplementedException("RESET LOCAL is not implemented.");
 	}
 
-	auto name = std::string(stmt->name);
+	auto name = std::string(stmt.name);
 	D_ASSERT(!name.empty()); // parser protect us!
 
-	return make_uniq<ResetVariableStatement>(name, ToSetScope(stmt->scope));
+	return make_uniq<ResetVariableStatement>(name, ToSetScope(stmt.scope));
 }
 
-unique_ptr<SetStatement> Transformer::TransformSet(duckdb_libpgquery::PGNode *node) {
-	D_ASSERT(node->type == duckdb_libpgquery::T_PGVariableSetStmt);
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGVariableSetStmt *>(node);
+unique_ptr<SetStatement> Transformer::TransformSet(duckdb_libpgquery::PGVariableSetStmt &stmt) {
+	D_ASSERT(stmt.type == duckdb_libpgquery::T_PGVariableSetStmt);
 
-	SetType set_type = ToSetType(stmt->kind);
+	SetType set_type = ToSetType(stmt.kind);
 
 	switch (set_type) {
 	case SetType::SET:

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

@@ -25,19 +25,17 @@ static void TransformShowName(unique_ptr<PragmaStatement> &result, const string
 	}
 }
 
-unique_ptr<SQLStatement> Transformer::TransformShow(duckdb_libpgquery::PGNode *node) {
+unique_ptr<SQLStatement> Transformer::TransformShow(duckdb_libpgquery::PGVariableShowStmt &stmt) {
 	// we transform SHOW x into PRAGMA SHOW('x')
-
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGVariableShowStmt *>(node);
-	if (stmt->is_summary) {
+	if (stmt.is_summary) {
 		auto result = make_uniq<ShowStatement>();
 		auto &info = *result->info;
-		info.is_summary = stmt->is_summary;
+		info.is_summary = stmt.is_summary;
 
 		auto select = make_uniq<SelectNode>();
 		select->select_list.push_back(make_uniq<StarExpression>());
 		auto basetable = make_uniq<BaseTableRef>();
-		auto qualified_name = QualifiedName::Parse(stmt->name);
+		auto qualified_name = QualifiedName::Parse(stmt.name);
 		basetable->schema_name = qualified_name.schema;
 		basetable->table_name = qualified_name.name;
 		select->from_table = std::move(basetable);
@@ -48,7 +46,7 @@ unique_ptr<SQLStatement> Transformer::TransformShow(duckdb_libpgquery::PGNode *n
 
 	auto result = make_uniq<PragmaStatement>();
 
-	auto show_name = stmt->name;
+	auto show_name = stmt.name;
 	TransformShowName(result, show_name);
 	return std::move(result);
 }

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

@@ -4,16 +4,15 @@
 
 namespace duckdb {
 
-unique_ptr<ShowStatement> Transformer::TransformShowSelect(duckdb_libpgquery::PGNode *node) {
+unique_ptr<ShowStatement> Transformer::TransformShowSelect(duckdb_libpgquery::PGVariableShowSelectStmt &stmt) {
 	// we capture the select statement of SHOW
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGVariableShowSelectStmt *>(node);
-	auto select_stmt = reinterpret_cast<duckdb_libpgquery::PGSelectStmt *>(stmt->stmt);
+	auto select_stmt = PGPointerCast<duckdb_libpgquery::PGSelectStmt>(stmt.stmt);
 
 	auto result = make_uniq<ShowStatement>();
 	auto &info = *result->info;
-	info.is_summary = stmt->is_summary;
+	info.is_summary = stmt.is_summary;
 
-	info.query = TransformSelectNode(select_stmt);
+	info.query = TransformSelectNode(*select_stmt);
 
 	return result;
 }

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

@@ -3,10 +3,8 @@
 
 namespace duckdb {
 
-unique_ptr<TransactionStatement> Transformer::TransformTransaction(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGTransactionStmt *>(node);
-	D_ASSERT(stmt);
-	switch (stmt->kind) {
+unique_ptr<TransactionStatement> Transformer::TransformTransaction(duckdb_libpgquery::PGTransactionStmt &stmt) {
+	switch (stmt.kind) {
 	case duckdb_libpgquery::PG_TRANS_STMT_BEGIN:
 	case duckdb_libpgquery::PG_TRANS_STMT_START:
 		return make_uniq<TransactionStatement>(TransactionType::BEGIN_TRANSACTION);
@@ -15,7 +13,7 @@ unique_ptr<TransactionStatement> Transformer::TransformTransaction(duckdb_libpgq
 	case duckdb_libpgquery::PG_TRANS_STMT_ROLLBACK:
 		return make_uniq<TransactionStatement>(TransactionType::ROLLBACK);
 	default:
-		throw NotImplementedException("Transaction type %d not implemented yet", stmt->kind);
+		throw NotImplementedException("Transaction type %d not implemented yet", stmt.kind);
 	}
 }
 

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

@@ -9,7 +9,7 @@ unique_ptr<UpdateSetInfo> Transformer::TransformUpdateSetInfo(duckdb_libpgquery:
 
 	auto root = target_list;
 	for (auto cell = root->head; cell != nullptr; cell = cell->next) {
-		auto target = (duckdb_libpgquery::PGResTarget *)(cell->data.ptr_value);
+		auto target = PGPointerCast<duckdb_libpgquery::PGResTarget>(cell->data.ptr_value);
 		result->columns.emplace_back(target->name);
 		result->expressions.push_back(TransformExpression(target->val));
 	}
@@ -17,25 +17,22 @@ unique_ptr<UpdateSetInfo> Transformer::TransformUpdateSetInfo(duckdb_libpgquery:
 	return result;
 }
 
-unique_ptr<UpdateStatement> Transformer::TransformUpdate(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGUpdateStmt *>(node);
-	D_ASSERT(stmt);
-
+unique_ptr<UpdateStatement> Transformer::TransformUpdate(duckdb_libpgquery::PGUpdateStmt &stmt) {
 	auto result = make_uniq<UpdateStatement>();
-	if (stmt->withClause) {
-		TransformCTE(reinterpret_cast<duckdb_libpgquery::PGWithClause *>(stmt->withClause), result->cte_map);
+	if (stmt.withClause) {
+		TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause), result->cte_map);
 	}
 
-	result->table = TransformRangeVar(stmt->relation);
-	if (stmt->fromClause) {
-		result->from_table = TransformFrom(stmt->fromClause);
+	result->table = TransformRangeVar(*stmt.relation);
+	if (stmt.fromClause) {
+		result->from_table = TransformFrom(stmt.fromClause);
 	}
 
-	result->set_info = TransformUpdateSetInfo(stmt->targetList, stmt->whereClause);
+	result->set_info = TransformUpdateSetInfo(stmt.targetList, stmt.whereClause);
 
 	// Grab and transform the returning columns from the parser.
-	if (stmt->returningList) {
-		Transformer::TransformExpressionList(*(stmt->returningList), result->returning_list);
+	if (stmt.returningList) {
+		TransformExpressionList(*stmt.returningList, result->returning_list);
 	}
 
 	return result;

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

@@ -21,10 +21,10 @@ OnConflictAction TransformOnConflictAction(duckdb_libpgquery::PGOnConflictClause
 	}
 }
 
-vector<string> TransformConflictTarget(duckdb_libpgquery::PGList *list) {
+vector<string> Transformer::TransformConflictTarget(duckdb_libpgquery::PGList &list) {
 	vector<string> columns;
-	for (auto cell = list->head; cell != nullptr; cell = cell->next) {
-		auto index_element = (duckdb_libpgquery::PGIndexElem *)cell->data.ptr_value;
+	for (auto cell = list.head; cell != nullptr; cell = cell->next) {
+		auto index_element = PGPointerCast<duckdb_libpgquery::PGIndexElem>(cell->data.ptr_value);
 		if (index_element->collation) {
 			throw NotImplementedException("Index with collation not supported yet!");
 		}
@@ -77,7 +77,7 @@ unique_ptr<OnConflictInfo> Transformer::TransformOnConflictClause(duckdb_libpgqu
 		// A filter for the ON CONFLICT ... is specified
 		if (stmt->infer->indexElems) {
 			// Columns are specified
-			result->indexed_columns = TransformConflictTarget(stmt->infer->indexElems);
+			result->indexed_columns = TransformConflictTarget(*stmt->infer->indexElems);
 			if (stmt->infer->whereClause) {
 				result->condition = TransformExpression(stmt->infer->whereClause);
 			}

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

@@ -3,9 +3,8 @@
 
 namespace duckdb {
 
-unique_ptr<SetStatement> Transformer::TransformUse(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGUseStmt *>(node);
-	auto qualified_name = TransformQualifiedName(stmt->name);
+unique_ptr<SetStatement> Transformer::TransformUse(duckdb_libpgquery::PGUseStmt &stmt) {
+	auto qualified_name = TransformQualifiedName(*stmt.name);
 	if (!IsInvalidCatalog(qualified_name.catalog)) {
 		throw ParserException("Expected \"USE database\" or \"USE database.schema\"");
 	}

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

@@ -32,25 +32,21 @@ VacuumOptions ParseOptions(int options) {
 	return result;
 }
 
-unique_ptr<SQLStatement> Transformer::TransformVacuum(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGVacuumStmt *>(node);
-	D_ASSERT(stmt);
+unique_ptr<SQLStatement> Transformer::TransformVacuum(duckdb_libpgquery::PGVacuumStmt &stmt) {
+	auto result = make_uniq<VacuumStatement>(ParseOptions(stmt.options));
 
-	auto result = make_uniq<VacuumStatement>(ParseOptions(stmt->options));
-
-	if (stmt->relation) {
-		result->info->ref = TransformRangeVar(stmt->relation);
+	if (stmt.relation) {
+		result->info->ref = TransformRangeVar(*stmt.relation);
 		result->info->has_table = true;
 	}
 
-	if (stmt->va_cols) {
+	if (stmt.va_cols) {
 		D_ASSERT(result->info->has_table);
-		for (auto col_node = stmt->va_cols->head; col_node != nullptr; col_node = col_node->next) {
+		for (auto col_node = stmt.va_cols->head; col_node != nullptr; col_node = col_node->next) {
 			result->info->columns.emplace_back(
 			    reinterpret_cast<duckdb_libpgquery::PGValue *>(col_node->data.ptr_value)->val.str);
 		}
 	}
-
 	return std::move(result);
 }
 

package/src/duckdb/src/parser/transform/tableref/transform_base_tableref.cpp

@@ -3,40 +3,40 @@
 
 namespace duckdb {
 
-unique_ptr<TableRef> Transformer::TransformRangeVar(duckdb_libpgquery::PGRangeVar *root) {
+unique_ptr<TableRef> Transformer::TransformRangeVar(duckdb_libpgquery::PGRangeVar &root) {
 	auto result = make_uniq<BaseTableRef>();
 
-	result->alias = TransformAlias(root->alias, result->column_name_alias);
-	if (root->relname) {
-		result->table_name = root->relname;
+	result->alias = TransformAlias(root.alias, result->column_name_alias);
+	if (root.relname) {
+		result->table_name = root.relname;
 	}
-	if (root->catalogname) {
-		result->catalog_name = root->catalogname;
+	if (root.catalogname) {
+		result->catalog_name = root.catalogname;
 	}
-	if (root->schemaname) {
-		result->schema_name = root->schemaname;
+	if (root.schemaname) {
+		result->schema_name = root.schemaname;
 	}
-	if (root->sample) {
-		result->sample = TransformSampleOptions(root->sample);
+	if (root.sample) {
+		result->sample = TransformSampleOptions(root.sample);
 	}
-	result->query_location = root->location;
+	result->query_location = root.location;
 	return std::move(result);
 }
 
-QualifiedName Transformer::TransformQualifiedName(duckdb_libpgquery::PGRangeVar *root) {
+QualifiedName Transformer::TransformQualifiedName(duckdb_libpgquery::PGRangeVar &root) {
 	QualifiedName qname;
-	if (root->catalogname) {
-		qname.catalog = root->catalogname;
+	if (root.catalogname) {
+		qname.catalog = root.catalogname;
 	} else {
 		qname.catalog = INVALID_CATALOG;
 	}
-	if (root->schemaname) {
-		qname.schema = root->schemaname;
+	if (root.schemaname) {
+		qname.schema = root.schemaname;
 	} else {
 		qname.schema = INVALID_SCHEMA;
 	}
-	if (root->relname) {
-		qname.name = root->relname;
+	if (root.relname) {
+		qname.name = root.relname;
 	} else {
 		qname.name = string();
 	}

package/src/duckdb/src/parser/transform/tableref/transform_from.cpp

@@ -4,7 +4,7 @@
 
 namespace duckdb {
 
-unique_ptr<TableRef> Transformer::TransformFrom(duckdb_libpgquery::PGList *root) {
+unique_ptr<TableRef> Transformer::TransformFrom(optional_ptr<duckdb_libpgquery::PGList> root) {
 	if (!root) {
 		return make_uniq<EmptyTableRef>();
 	}
@@ -15,8 +15,8 @@ unique_ptr<TableRef> Transformer::TransformFrom(duckdb_libpgquery::PGList *root)
 		JoinRef *cur_root = result.get();
 		idx_t list_size = 0;
 		for (auto node = root->head; node != nullptr; node = node->next) {
-			auto n = reinterpret_cast<duckdb_libpgquery::PGNode *>(node->data.ptr_value);
-			unique_ptr<TableRef> next = TransformTableRefNode(n);
+			auto n = PGPointerCast<duckdb_libpgquery::PGNode>(node->data.ptr_value);
+			unique_ptr<TableRef> next = TransformTableRefNode(*n);
 			if (!cur_root->left) {
 				cur_root->left = std::move(next);
 			} else if (!cur_root->right) {
@@ -34,8 +34,8 @@ unique_ptr<TableRef> Transformer::TransformFrom(duckdb_libpgquery::PGList *root)
 		return std::move(result);
 	}
 
-	auto n = reinterpret_cast<duckdb_libpgquery::PGNode *>(root->head->data.ptr_value);
-	return TransformTableRefNode(n);
+	auto n = PGPointerCast<duckdb_libpgquery::PGNode>(root->head->data.ptr_value);
+	return TransformTableRefNode(*n);
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/transform/tableref/transform_join.cpp

@@ -5,9 +5,9 @@
 
 namespace duckdb {
 
-unique_ptr<TableRef> Transformer::TransformJoin(duckdb_libpgquery::PGJoinExpr *root) {
+unique_ptr<TableRef> Transformer::TransformJoin(duckdb_libpgquery::PGJoinExpr &root) {
 	auto result = make_uniq<JoinRef>(JoinRefType::REGULAR);
-	switch (root->jointype) {
+	switch (root.jointype) {
 	case duckdb_libpgquery::PG_JOIN_INNER: {
 		result->type = JoinType::INNER;
 		break;
@@ -37,14 +37,14 @@ unique_ptr<TableRef> Transformer::TransformJoin(duckdb_libpgquery::PGJoinExpr *r
 		break;
 	}
 	default: {
-		throw NotImplementedException("Join type %d not supported\n", root->jointype);
+		throw NotImplementedException("Join type %d not supported\n", root.jointype);
 	}
 	}
 
 	// Check the type of left arg and right arg before transform
-	result->left = TransformTableRefNode(root->larg);
-	result->right = TransformTableRefNode(root->rarg);
-	switch (root->joinreftype) {
+	result->left = TransformTableRefNode(*root.larg);
+	result->right = TransformTableRefNode(*root.rarg);
+	switch (root.joinreftype) {
 	case duckdb_libpgquery::PG_JOIN_NATURAL:
 		result->ref_type = JoinRefType::NATURAL;
 		break;
@@ -54,11 +54,11 @@ unique_ptr<TableRef> Transformer::TransformJoin(duckdb_libpgquery::PGJoinExpr *r
 	default:
 		break;
 	}
-	result->query_location = root->location;
+	result->query_location = root.location;
 
-	if (root->usingClause && root->usingClause->length > 0) {
+	if (root.usingClause && root.usingClause->length > 0) {
 		// usingClause is a list of strings
-		for (auto node = root->usingClause->head; node != nullptr; node = node->next) {
+		for (auto node = root.usingClause->head; node != nullptr; node = node->next) {
 			auto target = reinterpret_cast<duckdb_libpgquery::PGNode *>(node->data.ptr_value);
 			D_ASSERT(target->type == duckdb_libpgquery::T_PGString);
 			auto column_name = string(reinterpret_cast<duckdb_libpgquery::PGValue *>(target)->val.str);
@@ -67,10 +67,10 @@ unique_ptr<TableRef> Transformer::TransformJoin(duckdb_libpgquery::PGJoinExpr *r
 		return std::move(result);
 	}
 
-	if (!root->quals && result->using_columns.empty() && result->ref_type == JoinRefType::REGULAR) { // CROSS PRODUCT
+	if (!root.quals && result->using_columns.empty() && result->ref_type == JoinRefType::REGULAR) { // CROSS PRODUCT
 		result->ref_type = JoinRefType::CROSS;
 	}
-	result->condition = TransformExpression(root->quals);
+	result->condition = TransformExpression(root.quals);
 	return std::move(result);
 }