duckdb 0.8.1-dev51.0 → 0.8.1-dev96.0

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

@@ -123,14 +123,14 @@ unique_ptr<SQLStatement> Transformer::CreatePivotStatement(unique_ptr<SQLStateme
 	return std::move(result);
 }
 
-unique_ptr<QueryNode> Transformer::TransformPivotStatement(duckdb_libpgquery::PGSelectStmt *stmt) {
-	auto pivot = stmt->pivot;
-	auto source = TransformTableRefNode(pivot->source);
+unique_ptr<QueryNode> Transformer::TransformPivotStatement(duckdb_libpgquery::PGSelectStmt &select) {
+	auto pivot = select.pivot;
+	auto source = TransformTableRefNode(*pivot->source);
 
 	auto select_node = make_uniq<SelectNode>();
 	// handle the CTEs
-	if (stmt->withClause) {
-		TransformCTE(reinterpret_cast<duckdb_libpgquery::PGWithClause *>(stmt->withClause), select_node->cte_map);
+	if (select.withClause) {
+		TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(select.withClause), select_node->cte_map);
 	}
 	if (!pivot->columns) {
 		// no pivot columns - not actually a pivot
@@ -154,7 +154,7 @@ unique_ptr<QueryNode> Transformer::TransformPivotStatement(duckdb_libpgquery::PG
 	}
 
 	// generate CREATE TYPE statements for each of the columns that do not have an IN list
-	auto columns = TransformPivotList(pivot->columns);
+	auto columns = TransformPivotList(*pivot->columns);
 	auto pivot_idx = PivotEntryCount();
 	for (idx_t c = 0; c < columns.size(); c++) {
 		auto &col = columns[c];
@@ -196,7 +196,7 @@ unique_ptr<QueryNode> Transformer::TransformPivotStatement(duckdb_libpgquery::PG
 	pivot_ref->pivots = std::move(columns);
 	select_node->from_table = std::move(pivot_ref);
 	// transform order by/limit modifiers
-	TransformModifiers(*stmt, *select_node);
+	TransformModifiers(select, *select_node);
 	return std::move(select_node);
 }
 

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

@@ -9,17 +9,15 @@
 
 namespace duckdb {
 
-unique_ptr<SQLStatement> Transformer::TransformPragma(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGPragmaStmt *>(node);
-
+unique_ptr<SQLStatement> Transformer::TransformPragma(duckdb_libpgquery::PGPragmaStmt &stmt) {
 	auto result = make_uniq<PragmaStatement>();
 	auto &info = *result->info;
 
-	info.name = stmt->name;
+	info.name = stmt.name;
 	// parse the arguments, if any
-	if (stmt->args) {
-		for (auto cell = stmt->args->head; cell != nullptr; cell = cell->next) {
-			auto node = reinterpret_cast<duckdb_libpgquery::PGNode *>(cell->data.ptr_value);
+	if (stmt.args) {
+		for (auto cell = stmt.args->head; cell != nullptr; cell = cell->next) {
+			auto node = PGPointerCast<duckdb_libpgquery::PGNode>(cell->data.ptr_value);
 			auto expr = TransformExpression(node);
 
 			if (expr->type == ExpressionType::COMPARE_EQUAL) {
@@ -34,7 +32,7 @@ unique_ptr<SQLStatement> Transformer::TransformPragma(duckdb_libpgquery::PGNode
 				auto &constant = comp.right->Cast<ConstantExpression>();
 				info.named_parameters[columnref.GetName()] = constant.value;
 			} else if (node->type == duckdb_libpgquery::T_PGAConst) {
-				auto constant = TransformConstant((duckdb_libpgquery::PGAConst *)node);
+				auto constant = TransformConstant(*PGPointerCast<duckdb_libpgquery::PGAConst>(node.get()));
 				info.parameters.push_back((constant->Cast<ConstantExpression>()).value);
 			} else if (expr->type == ExpressionType::COLUMN_REF) {
 				auto &colref = expr->Cast<ColumnRefExpression>();
@@ -49,7 +47,7 @@ unique_ptr<SQLStatement> Transformer::TransformPragma(duckdb_libpgquery::PGNode
 		}
 	}
 	// now parse the pragma type
-	switch (stmt->kind) {
+	switch (stmt.kind) {
 	case duckdb_libpgquery::PG_PRAGMA_TYPE_NOTHING: {
 		if (!info.parameters.empty() || !info.named_parameters.empty()) {
 			throw InternalException("PRAGMA statement that is not a call or assignment cannot contain parameters");

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

@@ -5,17 +5,14 @@
 
 namespace duckdb {
 
-unique_ptr<PrepareStatement> Transformer::TransformPrepare(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGPrepareStmt *>(node);
-	D_ASSERT(stmt);
-
-	if (stmt->argtypes && stmt->argtypes->length > 0) {
+unique_ptr<PrepareStatement> Transformer::TransformPrepare(duckdb_libpgquery::PGPrepareStmt &stmt) {
+	if (stmt.argtypes && stmt.argtypes->length > 0) {
 		throw NotImplementedException("Prepared statement argument types are not supported, use CAST");
 	}
 
 	auto result = make_uniq<PrepareStatement>();
-	result->name = string(stmt->name);
-	result->statement = TransformStatement(stmt->query);
+	result->name = string(stmt.name);
+	result->statement = TransformStatement(*stmt.query);
 	if (!result->statement->named_param_map.empty()) {
 		throw NotImplementedException("Named parameters are not supported in this client yet");
 	}
@@ -24,15 +21,12 @@ unique_ptr<PrepareStatement> Transformer::TransformPrepare(duckdb_libpgquery::PG
 	return result;
 }
 
-unique_ptr<ExecuteStatement> Transformer::TransformExecute(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGExecuteStmt *>(node);
-	D_ASSERT(stmt);
-
+unique_ptr<ExecuteStatement> Transformer::TransformExecute(duckdb_libpgquery::PGExecuteStmt &stmt) {
 	auto result = make_uniq<ExecuteStatement>();
-	result->name = string(stmt->name);
+	result->name = string(stmt.name);
 
-	if (stmt->params) {
-		TransformExpressionList(*stmt->params, result->values);
+	if (stmt.params) {
+		TransformExpressionList(*stmt.params, result->values);
 	}
 	for (auto &expr : result->values) {
 		if (!expr->IsScalar()) {
@@ -42,16 +36,14 @@ unique_ptr<ExecuteStatement> Transformer::TransformExecute(duckdb_libpgquery::PG
 	return result;
 }
 
-unique_ptr<DropStatement> Transformer::TransformDeallocate(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGDeallocateStmt *>(node);
-	D_ASSERT(stmt);
-	if (!stmt->name) {
+unique_ptr<DropStatement> Transformer::TransformDeallocate(duckdb_libpgquery::PGDeallocateStmt &stmt) {
+	if (!stmt.name) {
 		throw ParserException("DEALLOCATE requires a name");
 	}
 
 	auto result = make_uniq<DropStatement>();
 	result->info->type = CatalogType::PREPARED_STATEMENT;
-	result->info->name = string(stmt->name);
+	result->info->name = string(stmt.name);
 	return result;
 }
 

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

@@ -3,42 +3,40 @@
 
 namespace duckdb {
 
-unique_ptr<AlterStatement> Transformer::TransformRename(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGRenameStmt *>(node);
-	D_ASSERT(stmt);
-	if (!stmt->relation) {
+unique_ptr<AlterStatement> Transformer::TransformRename(duckdb_libpgquery::PGRenameStmt &stmt) {
+	if (!stmt.relation) {
 		throw NotImplementedException("Altering schemas is not yet supported");
 	}
 
 	unique_ptr<AlterInfo> info;
 
 	AlterEntryData data;
-	data.if_not_found = TransformOnEntryNotFound(stmt->missing_ok);
-	data.catalog = stmt->relation->catalogname ? stmt->relation->catalogname : INVALID_CATALOG;
-	data.schema = stmt->relation->schemaname ? stmt->relation->schemaname : INVALID_SCHEMA;
-	if (stmt->relation->relname) {
-		data.name = stmt->relation->relname;
+	data.if_not_found = TransformOnEntryNotFound(stmt.missing_ok);
+	data.catalog = stmt.relation->catalogname ? stmt.relation->catalogname : INVALID_CATALOG;
+	data.schema = stmt.relation->schemaname ? stmt.relation->schemaname : INVALID_SCHEMA;
+	if (stmt.relation->relname) {
+		data.name = stmt.relation->relname;
 	}
 	// first we check the type of ALTER
-	switch (stmt->renameType) {
+	switch (stmt.renameType) {
 	case duckdb_libpgquery::PG_OBJECT_COLUMN: {
 		// change column name
 
 		// get the old name and the new name
-		string old_name = stmt->subname;
-		string new_name = stmt->newname;
+		string old_name = stmt.subname;
+		string new_name = stmt.newname;
 		info = make_uniq<RenameColumnInfo>(std::move(data), old_name, new_name);
 		break;
 	}
 	case duckdb_libpgquery::PG_OBJECT_TABLE: {
 		// change table name
-		string new_name = stmt->newname;
+		string new_name = stmt.newname;
 		info = make_uniq<RenameTableInfo>(std::move(data), new_name);
 		break;
 	}
 	case duckdb_libpgquery::PG_OBJECT_VIEW: {
 		// change view name
-		string new_name = stmt->newname;
+		string new_name = stmt.newname;
 		info = make_uniq<RenameViewInfo>(std::move(data), new_name);
 		break;
 	}

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

@@ -4,30 +4,33 @@
 
 namespace duckdb {
 
-unique_ptr<QueryNode> Transformer::TransformSelectNode(duckdb_libpgquery::PGSelectStmt *stmt) {
-	if (stmt->pivot) {
-		return TransformPivotStatement(stmt);
+unique_ptr<QueryNode> Transformer::TransformSelectNode(duckdb_libpgquery::PGSelectStmt &select) {
+	if (select.pivot) {
+		return TransformPivotStatement(select);
 	} else {
-		return TransformSelectInternal(stmt);
+		return TransformSelectInternal(select);
 	}
 }
 
-unique_ptr<SelectStatement> Transformer::TransformSelect(duckdb_libpgquery::PGNode *node, bool is_select) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGSelectStmt *>(node);
+unique_ptr<SelectStatement> Transformer::TransformSelect(duckdb_libpgquery::PGSelectStmt &select, bool is_select) {
 	auto result = make_uniq<SelectStatement>();
 
 	// Both Insert/Create Table As uses this.
 	if (is_select) {
-		if (stmt->intoClause) {
+		if (select.intoClause) {
 			throw ParserException("SELECT INTO not supported!");
 		}
-		if (stmt->lockingClause) {
+		if (select.lockingClause) {
 			throw ParserException("SELECT locking clause is not supported!");
 		}
 	}
 
-	result->node = TransformSelectNode(stmt);
+	result->node = TransformSelectNode(select);
 	return result;
 }
 
+unique_ptr<SelectStatement> Transformer::TransformSelect(optional_ptr<duckdb_libpgquery::PGNode> node, bool is_select) {
+	return TransformSelect(PGCast<duckdb_libpgquery::PGSelectStmt>(*node), is_select);
+}
+
 } // namespace duckdb

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\"");
 	}