duckdb 0.8.1-dev31.0 → 0.8.1-dev327.0

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

@@ -5,16 +5,14 @@
 
 namespace duckdb {
 
-unique_ptr<SQLStatement> Transformer::TransformCheckpoint(duckdb_libpgquery::PGNode *node) {
-	auto checkpoint = (duckdb_libpgquery::PGCheckPointStmt *)node;
-
+unique_ptr<SQLStatement> Transformer::TransformCheckpoint(duckdb_libpgquery::PGCheckPointStmt &stmt) {
 	vector<unique_ptr<ParsedExpression>> children;
 	// transform into "CALL checkpoint()" or "CALL force_checkpoint()"
-	auto checkpoint_name = checkpoint->force ? "force_checkpoint" : "checkpoint";
+	auto checkpoint_name = stmt.force ? "force_checkpoint" : "checkpoint";
 	auto result = make_uniq<CallStatement>();
 	auto function = make_uniq<FunctionExpression>(checkpoint_name, std::move(children));
-	if (checkpoint->name) {
-		function->children.push_back(make_uniq<ConstantExpression>(Value(checkpoint->name)));
+	if (stmt.name) {
+		function->children.push_back(make_uniq<ConstantExpression>(Value(stmt.name)));
 	}
 	result->function = std::move(function);
 	return std::move(result);

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

@@ -9,18 +9,18 @@
 
 namespace duckdb {
 
-void Transformer::TransformCopyOptions(CopyInfo &info, duckdb_libpgquery::PGList *options) {
+void Transformer::TransformCopyOptions(CopyInfo &info, optional_ptr<duckdb_libpgquery::PGList> options) {
 	if (!options) {
 		return;
 	}
-	duckdb_libpgquery::PGListCell *cell = nullptr;
 
 	// iterate over each option
+	duckdb_libpgquery::PGListCell *cell;
 	for_each_cell(cell, options->head) {
-		auto *def_elem = reinterpret_cast<duckdb_libpgquery::PGDefElem *>(cell->data.ptr_value);
+		auto def_elem = PGPointerCast<duckdb_libpgquery::PGDefElem>(cell->data.ptr_value);
 		if (StringUtil::Lower(def_elem->defname) == "format") {
 			// format specifier: interpret this option
-			auto *format_val = (duckdb_libpgquery::PGValue *)(def_elem->arg);
+			auto format_val = PGPointerCast<duckdb_libpgquery::PGValue>(def_elem->arg);
 			if (!format_val || format_val->type != duckdb_libpgquery::T_PGString) {
 				throw ParserException("Unsupported parameter type for FORMAT: expected e.g. FORMAT 'csv', 'parquet'");
 			}
@@ -37,9 +37,9 @@ void Transformer::TransformCopyOptions(CopyInfo &info, duckdb_libpgquery::PGList
 		}
 		switch (def_elem->arg->type) {
 		case duckdb_libpgquery::T_PGList: {
-			auto column_list = (duckdb_libpgquery::PGList *)(def_elem->arg);
+			auto column_list = PGPointerCast<duckdb_libpgquery::PGList>(def_elem->arg);
 			for (auto c = column_list->head; c != nullptr; c = lnext(c)) {
-				auto target = (duckdb_libpgquery::PGResTarget *)(c->data.ptr_value);
+				auto target = PGPointerCast<duckdb_libpgquery::PGResTarget>(c->data.ptr_value);
 				info.options[def_elem->defname].push_back(Value(target->name));
 			}
 			break;
@@ -47,28 +47,27 @@ void Transformer::TransformCopyOptions(CopyInfo &info, duckdb_libpgquery::PGList
 		case duckdb_libpgquery::T_PGAStar:
 			info.options[def_elem->defname].push_back(Value("*"));
 			break;
-		default:
-			info.options[def_elem->defname].push_back(
-			    TransformValue(*((duckdb_libpgquery::PGValue *)def_elem->arg))->value);
+		default: {
+			auto val = PGPointerCast<duckdb_libpgquery::PGValue>(def_elem->arg);
+			info.options[def_elem->defname].push_back(TransformValue(*val)->value);
 			break;
 		}
+		}
 	}
 }
 
-unique_ptr<CopyStatement> Transformer::TransformCopy(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGCopyStmt *>(node);
-	D_ASSERT(stmt);
+unique_ptr<CopyStatement> Transformer::TransformCopy(duckdb_libpgquery::PGCopyStmt &stmt) {
 	auto result = make_uniq<CopyStatement>();
 	auto &info = *result->info;
 
 	// get file_path and is_from
-	info.is_from = stmt->is_from;
-	if (!stmt->filename) {
+	info.is_from = stmt.is_from;
+	if (!stmt.filename) {
 		// stdin/stdout
 		info.file_path = info.is_from ? "/dev/stdin" : "/dev/stdout";
 	} else {
 		// copy to a file
-		info.file_path = stmt->filename;
+		info.file_path = stmt.filename;
 	}
 	if (StringUtil::EndsWith(info.file_path, ".parquet")) {
 		info.format = "parquet";
@@ -79,27 +78,27 @@ unique_ptr<CopyStatement> Transformer::TransformCopy(duckdb_libpgquery::PGNode *
 	}
 
 	// get select_list
-	if (stmt->attlist) {
-		for (auto n = stmt->attlist->head; n != nullptr; n = n->next) {
-			auto target = reinterpret_cast<duckdb_libpgquery::PGResTarget *>(n->data.ptr_value);
+	if (stmt.attlist) {
+		for (auto n = stmt.attlist->head; n != nullptr; n = n->next) {
+			auto target = PGPointerCast<duckdb_libpgquery::PGResTarget>(n->data.ptr_value);
 			if (target->name) {
 				info.select_list.emplace_back(target->name);
 			}
 		}
 	}
 
-	if (stmt->relation) {
-		auto ref = TransformRangeVar(stmt->relation);
-		auto &table = *reinterpret_cast<BaseTableRef *>(ref.get());
+	if (stmt.relation) {
+		auto ref = TransformRangeVar(*stmt.relation);
+		auto &table = ref->Cast<BaseTableRef>();
 		info.table = table.table_name;
 		info.schema = table.schema_name;
 		info.catalog = table.catalog_name;
 	} else {
-		result->select_statement = TransformSelectNode((duckdb_libpgquery::PGSelectStmt *)stmt->query);
+		result->select_statement = TransformSelectNode(*PGPointerCast<duckdb_libpgquery::PGSelectStmt>(stmt.query));
 	}
 
 	// handle the different options of the COPY statement
-	TransformCopyOptions(info, stmt->options);
+	TransformCopyOptions(info, stmt.options);
 
 	return result;
 }

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

@@ -8,37 +8,33 @@
 
 namespace duckdb {
 
-unique_ptr<CreateStatement> Transformer::TransformCreateFunction(duckdb_libpgquery::PGNode *node) {
-	D_ASSERT(node);
-	D_ASSERT(node->type == duckdb_libpgquery::T_PGCreateFunctionStmt);
-
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGCreateFunctionStmt *>(node);
-	D_ASSERT(stmt);
-	D_ASSERT(stmt->function || stmt->query);
+unique_ptr<CreateStatement> Transformer::TransformCreateFunction(duckdb_libpgquery::PGCreateFunctionStmt &stmt) {
+	D_ASSERT(stmt.type == duckdb_libpgquery::T_PGCreateFunctionStmt);
+	D_ASSERT(stmt.function || stmt.query);
 
 	auto result = make_uniq<CreateStatement>();
-	auto qname = TransformQualifiedName(stmt->name);
+	auto qname = TransformQualifiedName(*stmt.name);
 
 	unique_ptr<MacroFunction> macro_func;
 
 	// function can be null here
-	if (stmt->function) {
-		auto expression = TransformExpression(stmt->function);
+	if (stmt.function) {
+		auto expression = TransformExpression(stmt.function);
 		macro_func = make_uniq<ScalarMacroFunction>(std::move(expression));
-	} else if (stmt->query) {
-		auto query_node = TransformSelect(stmt->query, true)->node->Copy();
+	} else if (stmt.query) {
+		auto query_node =
+		    TransformSelect(*PGPointerCast<duckdb_libpgquery::PGSelectStmt>(stmt.query), true)->node->Copy();
 		macro_func = make_uniq<TableMacroFunction>(std::move(query_node));
 	}
 	PivotEntryCheck("macro");
 
-	auto info =
-	    make_uniq<CreateMacroInfo>((stmt->function ? CatalogType::MACRO_ENTRY : CatalogType::TABLE_MACRO_ENTRY));
+	auto info = make_uniq<CreateMacroInfo>(stmt.function ? CatalogType::MACRO_ENTRY : CatalogType::TABLE_MACRO_ENTRY);
 	info->catalog = qname.catalog;
 	info->schema = qname.schema;
 	info->name = qname.name;
 
 	// temporary macro
-	switch (stmt->name->relpersistence) {
+	switch (stmt.name->relpersistence) {
 	case duckdb_libpgquery::PG_RELPERSISTENCE_TEMP:
 		info->temporary = true;
 		break;
@@ -51,11 +47,11 @@ unique_ptr<CreateStatement> Transformer::TransformCreateFunction(duckdb_libpgque
 	}
 
 	// what to do on conflict
-	info->on_conflict = TransformOnConflict(stmt->onconflict);
+	info->on_conflict = TransformOnConflict(stmt.onconflict);
 
-	if (stmt->params) {
+	if (stmt.params) {
 		vector<unique_ptr<ParsedExpression>> parameters;
-		TransformExpressionList(*stmt->params, parameters);
+		TransformExpressionList(*stmt.params, parameters);
 		for (auto &param : parameters) {
 			if (param->type == ExpressionType::VALUE_CONSTANT) {
 				// parameters with default value (must have an alias)

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

@@ -19,11 +19,11 @@ static IndexType StringToIndexType(const string &str) {
 	return IndexType::INVALID;
 }
 
-vector<unique_ptr<ParsedExpression>> Transformer::TransformIndexParameters(duckdb_libpgquery::PGList *list,
+vector<unique_ptr<ParsedExpression>> Transformer::TransformIndexParameters(duckdb_libpgquery::PGList &list,
                                                                            const string &relation_name) {
 	vector<unique_ptr<ParsedExpression>> expressions;
-	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!");
 		}
@@ -43,30 +43,28 @@ vector<unique_ptr<ParsedExpression>> Transformer::TransformIndexParameters(duckd
 	return expressions;
 }
 
-unique_ptr<CreateStatement> Transformer::TransformCreateIndex(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGIndexStmt *>(node);
-	D_ASSERT(stmt);
+unique_ptr<CreateStatement> Transformer::TransformCreateIndex(duckdb_libpgquery::PGIndexStmt &stmt) {
 	auto result = make_uniq<CreateStatement>();
 	auto info = make_uniq<CreateIndexInfo>();
-	if (stmt->unique) {
+	if (stmt.unique) {
 		info->constraint_type = IndexConstraintType::UNIQUE;
 	} else {
 		info->constraint_type = IndexConstraintType::NONE;
 	}
 
-	info->on_conflict = TransformOnConflict(stmt->onconflict);
+	info->on_conflict = TransformOnConflict(stmt.onconflict);
 
-	info->expressions = TransformIndexParameters(stmt->indexParams, stmt->relation->relname);
+	info->expressions = TransformIndexParameters(*stmt.indexParams, stmt.relation->relname);
 
-	info->index_type = StringToIndexType(string(stmt->accessMethod));
+	info->index_type = StringToIndexType(string(stmt.accessMethod));
 	auto tableref = make_uniq<BaseTableRef>();
-	tableref->table_name = stmt->relation->relname;
-	if (stmt->relation->schemaname) {
-		tableref->schema_name = stmt->relation->schemaname;
+	tableref->table_name = stmt.relation->relname;
+	if (stmt.relation->schemaname) {
+		tableref->schema_name = stmt.relation->schemaname;
 	}
 	info->table = std::move(tableref);
-	if (stmt->idxname) {
-		info->index_name = stmt->idxname;
+	if (stmt.idxname) {
+		info->index_name = stmt.idxname;
 	} else {
 		throw NotImplementedException("Index without a name not supported yet!");
 	}

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

@@ -4,21 +4,19 @@
 
 namespace duckdb {
 
-unique_ptr<CreateStatement> Transformer::TransformCreateSchema(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGCreateSchemaStmt *>(node);
-	D_ASSERT(stmt);
+unique_ptr<CreateStatement> Transformer::TransformCreateSchema(duckdb_libpgquery::PGCreateSchemaStmt &stmt) {
 	auto result = make_uniq<CreateStatement>();
 	auto info = make_uniq<CreateSchemaInfo>();
 
-	D_ASSERT(stmt->schemaname);
-	info->catalog = stmt->catalogname ? stmt->catalogname : INVALID_CATALOG;
-	info->schema = stmt->schemaname;
-	info->on_conflict = TransformOnConflict(stmt->onconflict);
+	D_ASSERT(stmt.schemaname);
+	info->catalog = stmt.catalogname ? stmt.catalogname : INVALID_CATALOG;
+	info->schema = stmt.schemaname;
+	info->on_conflict = TransformOnConflict(stmt.onconflict);
 
-	if (stmt->schemaElts) {
+	if (stmt.schemaElts) {
 		// schema elements
-		for (auto cell = stmt->schemaElts->head; cell != nullptr; cell = cell->next) {
-			auto node = reinterpret_cast<duckdb_libpgquery::PGNode *>(cell->data.ptr_value);
+		for (auto cell = stmt.schemaElts->head; cell != nullptr; cell = cell->next) {
+			auto node = PGPointerCast<duckdb_libpgquery::PGNode>(cell->data.ptr_value);
 			switch (node->type) {
 			case duckdb_libpgquery::T_PGCreateStmt:
 			case duckdb_libpgquery::T_PGViewStmt:

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

@@ -7,24 +7,22 @@
 
 namespace duckdb {
 
-unique_ptr<CreateStatement> Transformer::TransformCreateSequence(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGCreateSeqStmt *>(node);
-
+unique_ptr<CreateStatement> Transformer::TransformCreateSequence(duckdb_libpgquery::PGCreateSeqStmt &stmt) {
 	auto result = make_uniq<CreateStatement>();
 	auto info = make_uniq<CreateSequenceInfo>();
 
-	auto qname = TransformQualifiedName(stmt->sequence);
+	auto qname = TransformQualifiedName(*stmt.sequence);
 	info->catalog = qname.catalog;
 	info->schema = qname.schema;
 	info->name = qname.name;
 
-	if (stmt->options) {
+	if (stmt.options) {
 		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);
+		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);
-			auto val = (duckdb_libpgquery::PGValue *)def_elem->arg;
+			auto val = PGPointerCast<duckdb_libpgquery::PGValue>(def_elem->arg);
 			bool nodef = def_elem->defaction == duckdb_libpgquery::PG_DEFELEM_UNSPEC && !val; // e.g. NO MINVALUE
 			int64_t opt_value = 0;
 
@@ -110,8 +108,8 @@ unique_ptr<CreateStatement> Transformer::TransformCreateSequence(duckdb_libpgque
 			}
 		}
 	}
-	info->temporary = !stmt->sequence->relpersistence;
-	info->on_conflict = TransformOnConflict(stmt->onconflict);
+	info->temporary = !stmt.sequence->relpersistence;
+	info->on_conflict = TransformOnConflict(stmt.onconflict);
 	if (info->max_value <= info->min_value) {
 		throw ParserException("MINVALUE (%lld) must be less than MAXVALUE (%lld)", info->min_value, info->max_value);
 	}

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

@@ -8,13 +8,13 @@
 
 namespace duckdb {
 
-string Transformer::TransformCollation(duckdb_libpgquery::PGCollateClause *collate) {
+string Transformer::TransformCollation(optional_ptr<duckdb_libpgquery::PGCollateClause> collate) {
 	if (!collate) {
 		return string();
 	}
 	string collation;
 	for (auto c = collate->collname->head; c != nullptr; c = lnext(c)) {
-		auto pgvalue = (duckdb_libpgquery::PGValue *)c->data.ptr_value;
+		auto pgvalue = PGPointerCast<duckdb_libpgquery::PGValue>(c->data.ptr_value);
 		if (pgvalue->type != duckdb_libpgquery::T_PGString) {
 			throw ParserException("Expected a string as collation type!");
 		}
@@ -41,67 +41,65 @@ OnCreateConflict Transformer::TransformOnConflict(duckdb_libpgquery::PGOnCreateC
 	}
 }
 
-unique_ptr<ParsedExpression> Transformer::TransformCollateExpr(duckdb_libpgquery::PGCollateClause *collate) {
-	auto child = TransformExpression(collate->arg);
-	auto collation = TransformCollation(collate);
+unique_ptr<ParsedExpression> Transformer::TransformCollateExpr(duckdb_libpgquery::PGCollateClause &collate) {
+	auto child = TransformExpression(collate.arg);
+	auto collation = TransformCollation(&collate);
 	return make_uniq<CollateExpression>(collation, std::move(child));
 }
 
-ColumnDefinition Transformer::TransformColumnDefinition(duckdb_libpgquery::PGColumnDef *cdef) {
+ColumnDefinition Transformer::TransformColumnDefinition(duckdb_libpgquery::PGColumnDef &cdef) {
 	string colname;
-	if (cdef->colname) {
-		colname = cdef->colname;
+	if (cdef.colname) {
+		colname = cdef.colname;
 	}
-	bool optional_type = cdef->category == duckdb_libpgquery::COL_GENERATED;
-	LogicalType target_type = (optional_type && !cdef->typeName) ? LogicalType::ANY : TransformTypeName(cdef->typeName);
-	if (cdef->collClause) {
-		if (cdef->category == duckdb_libpgquery::COL_GENERATED) {
+	bool optional_type = cdef.category == duckdb_libpgquery::COL_GENERATED;
+	LogicalType target_type = (optional_type && !cdef.typeName) ? LogicalType::ANY : TransformTypeName(*cdef.typeName);
+	if (cdef.collClause) {
+		if (cdef.category == duckdb_libpgquery::COL_GENERATED) {
 			throw ParserException("Collations are not supported on generated columns");
 		}
 		if (target_type.id() != LogicalTypeId::VARCHAR) {
 			throw ParserException("Only VARCHAR columns can have collations!");
 		}
-		target_type = LogicalType::VARCHAR_COLLATION(TransformCollation(cdef->collClause));
+		target_type = LogicalType::VARCHAR_COLLATION(TransformCollation(cdef.collClause));
 	}
 
 	return ColumnDefinition(colname, target_type);
 }
 
-unique_ptr<CreateStatement> Transformer::TransformCreateTable(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGCreateStmt *>(node);
-	D_ASSERT(stmt);
+unique_ptr<CreateStatement> Transformer::TransformCreateTable(duckdb_libpgquery::PGCreateStmt &stmt) {
 	auto result = make_uniq<CreateStatement>();
 	auto info = make_uniq<CreateTableInfo>();
 
-	if (stmt->inhRelations) {
+	if (stmt.inhRelations) {
 		throw NotImplementedException("inherited relations not implemented");
 	}
-	D_ASSERT(stmt->relation);
+	D_ASSERT(stmt.relation);
 
 	info->catalog = INVALID_CATALOG;
-	auto qname = TransformQualifiedName(stmt->relation);
+	auto qname = TransformQualifiedName(*stmt.relation);
 	info->catalog = qname.catalog;
 	info->schema = qname.schema;
 	info->table = qname.name;
-	info->on_conflict = TransformOnConflict(stmt->onconflict);
+	info->on_conflict = TransformOnConflict(stmt.onconflict);
 	info->temporary =
-	    stmt->relation->relpersistence == duckdb_libpgquery::PGPostgresRelPersistence::PG_RELPERSISTENCE_TEMP;
+	    stmt.relation->relpersistence == duckdb_libpgquery::PGPostgresRelPersistence::PG_RELPERSISTENCE_TEMP;
 
-	if (info->temporary && stmt->oncommit != duckdb_libpgquery::PGOnCommitAction::PG_ONCOMMIT_PRESERVE_ROWS &&
-	    stmt->oncommit != duckdb_libpgquery::PGOnCommitAction::PG_ONCOMMIT_NOOP) {
+	if (info->temporary && stmt.oncommit != duckdb_libpgquery::PGOnCommitAction::PG_ONCOMMIT_PRESERVE_ROWS &&
+	    stmt.oncommit != duckdb_libpgquery::PGOnCommitAction::PG_ONCOMMIT_NOOP) {
 		throw NotImplementedException("Only ON COMMIT PRESERVE ROWS is supported");
 	}
-	if (!stmt->tableElts) {
+	if (!stmt.tableElts) {
 		throw ParserException("Table must have at least one column!");
 	}
 
 	idx_t column_count = 0;
-	for (auto c = stmt->tableElts->head; c != nullptr; c = lnext(c)) {
-		auto node = reinterpret_cast<duckdb_libpgquery::PGNode *>(c->data.ptr_value);
+	for (auto c = stmt.tableElts->head; c != nullptr; c = lnext(c)) {
+		auto node = PGPointerCast<duckdb_libpgquery::PGNode>(c->data.ptr_value);
 		switch (node->type) {
 		case duckdb_libpgquery::T_PGColumnDef: {
-			auto cdef = (duckdb_libpgquery::PGColumnDef *)c->data.ptr_value;
-			auto centry = TransformColumnDefinition(cdef);
+			auto cdef = PGPointerCast<duckdb_libpgquery::PGColumnDef>(c->data.ptr_value);
+			auto centry = TransformColumnDefinition(*cdef);
 			if (cdef->constraints) {
 				for (auto constr = cdef->constraints->head; constr != nullptr; constr = constr->next) {
 					auto constraint = TransformConstraint(constr, centry, info->columns.LogicalColumnCount());

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

@@ -4,29 +4,27 @@
 
 namespace duckdb {
 
-unique_ptr<CreateStatement> Transformer::TransformCreateTableAs(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGCreateTableAsStmt *>(node);
-	D_ASSERT(stmt);
-	if (stmt->relkind == duckdb_libpgquery::PG_OBJECT_MATVIEW) {
+unique_ptr<CreateStatement> Transformer::TransformCreateTableAs(duckdb_libpgquery::PGCreateTableAsStmt &stmt) {
+	if (stmt.relkind == duckdb_libpgquery::PG_OBJECT_MATVIEW) {
 		throw NotImplementedException("Materialized view not implemented");
 	}
-	if (stmt->is_select_into || stmt->into->colNames || stmt->into->options) {
+	if (stmt.is_select_into || stmt.into->colNames || stmt.into->options) {
 		throw NotImplementedException("Unimplemented features for CREATE TABLE as");
 	}
-	auto qname = TransformQualifiedName(stmt->into->rel);
-	if (stmt->query->type != duckdb_libpgquery::T_PGSelectStmt) {
+	auto qname = TransformQualifiedName(*stmt.into->rel);
+	if (stmt.query->type != duckdb_libpgquery::T_PGSelectStmt) {
 		throw ParserException("CREATE TABLE AS requires a SELECT clause");
 	}
-	auto query = TransformSelect(stmt->query, false);
+	auto query = TransformSelect(stmt.query, false);
 
 	auto result = make_uniq<CreateStatement>();
 	auto info = make_uniq<CreateTableInfo>();
 	info->catalog = qname.catalog;
 	info->schema = qname.schema;
 	info->table = qname.name;
-	info->on_conflict = TransformOnConflict(stmt->onconflict);
+	info->on_conflict = TransformOnConflict(stmt.onconflict);
 	info->temporary =
-	    stmt->into->rel->relpersistence == duckdb_libpgquery::PGPostgresRelPersistence::PG_RELPERSISTENCE_TEMP;
+	    stmt.into->rel->relpersistence == duckdb_libpgquery::PGPostgresRelPersistence::PG_RELPERSISTENCE_TEMP;
 	info->query = std::move(query);
 	result->info = std::move(info);
 	return result;

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

@@ -6,7 +6,7 @@
 
 namespace duckdb {
 
-Vector ReadPgListToVector(duckdb_libpgquery::PGList *column_list, idx_t &size) {
+Vector Transformer::PGListToVector(optional_ptr<duckdb_libpgquery::PGList> column_list, idx_t &size) {
 	if (!column_list) {
 		Vector result(LogicalType::VARCHAR);
 		return result;
@@ -21,8 +21,8 @@ Vector ReadPgListToVector(duckdb_libpgquery::PGList *column_list, idx_t &size) {
 
 	size = 0;
 	for (auto c = column_list->head; c != nullptr; c = lnext(c)) {
-		auto &type_val = *((duckdb_libpgquery::PGAConst *)c->data.ptr_value);
-		auto entry_value_node = (duckdb_libpgquery::PGValue)(type_val.val);
+		auto &type_val = *PGPointerCast<duckdb_libpgquery::PGAConst>(c->data.ptr_value);
+		auto &entry_value_node = type_val.val;
 		if (entry_value_node.type != duckdb_libpgquery::T_PGString) {
 			throw ParserException("Expected a string constant as value");
 		}
@@ -34,43 +34,40 @@ Vector ReadPgListToVector(duckdb_libpgquery::PGList *column_list, idx_t &size) {
 	return result;
 }
 
-unique_ptr<CreateStatement> Transformer::TransformCreateType(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGCreateTypeStmt *>(node);
-	D_ASSERT(stmt);
+unique_ptr<CreateStatement> Transformer::TransformCreateType(duckdb_libpgquery::PGCreateTypeStmt &stmt) {
 	auto result = make_uniq<CreateStatement>();
 	auto info = make_uniq<CreateTypeInfo>();
 
-	auto qualified_name = TransformQualifiedName(stmt->typeName);
+	auto qualified_name = TransformQualifiedName(*stmt.typeName);
 	info->catalog = qualified_name.catalog;
 	info->schema = qualified_name.schema;
 	info->name = qualified_name.name;
 
-	switch (stmt->kind) {
+	switch (stmt.kind) {
 	case duckdb_libpgquery::PG_NEWTYPE_ENUM: {
 		info->internal = false;
-		if (stmt->query) {
+		if (stmt.query) {
 			// CREATE TYPE mood AS ENUM (SELECT ...)
-			D_ASSERT(stmt->vals == nullptr);
-			auto query = TransformSelect(stmt->query, false);
+			D_ASSERT(stmt.vals == nullptr);
+			auto query = TransformSelect(stmt.query, false);
 			info->query = std::move(query);
 			info->type = LogicalType::INVALID;
 		} else {
-			D_ASSERT(stmt->query == nullptr);
+			D_ASSERT(stmt.query == nullptr);
 			idx_t size = 0;
-			auto ordered_array = ReadPgListToVector(stmt->vals, size);
+			auto ordered_array = PGListToVector(stmt.vals, size);
 			info->type = LogicalType::ENUM(info->name, ordered_array, size);
 		}
 	} break;
 
 	case duckdb_libpgquery::PG_NEWTYPE_ALIAS: {
-		LogicalType target_type = TransformTypeName(stmt->ofType);
+		LogicalType target_type = TransformTypeName(*stmt.ofType);
 		info->type = target_type;
 	} break;
 
 	default:
 		throw InternalException("Unknown kind of new type");
 	}
-
 	result->info = std::move(info);
 	return result;
 }

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

@@ -4,37 +4,32 @@
 
 namespace duckdb {
 
-unique_ptr<CreateStatement> Transformer::TransformCreateView(duckdb_libpgquery::PGNode *node) {
-	D_ASSERT(node);
-	D_ASSERT(node->type == duckdb_libpgquery::T_PGViewStmt);
-
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGViewStmt *>(node);
-	D_ASSERT(stmt);
-	D_ASSERT(stmt->view);
+unique_ptr<CreateStatement> Transformer::TransformCreateView(duckdb_libpgquery::PGViewStmt &stmt) {
+	D_ASSERT(stmt.type == duckdb_libpgquery::T_PGViewStmt);
+	D_ASSERT(stmt.view);
 
 	auto result = make_uniq<CreateStatement>();
 	auto info = make_uniq<CreateViewInfo>();
 
-	auto qname = TransformQualifiedName(stmt->view);
+	auto qname = TransformQualifiedName(*stmt.view);
 	info->catalog = qname.catalog;
 	info->schema = qname.schema;
 	info->view_name = qname.name;
-	info->temporary = !stmt->view->relpersistence;
+	info->temporary = !stmt.view->relpersistence;
 	if (info->temporary && IsInvalidCatalog(info->catalog)) {
 		info->catalog = TEMP_CATALOG;
 	}
-	info->on_conflict = TransformOnConflict(stmt->onconflict);
+	info->on_conflict = TransformOnConflict(stmt.onconflict);
 
-	info->query = TransformSelect(stmt->query, false);
+	info->query = TransformSelect(*PGPointerCast<duckdb_libpgquery::PGSelectStmt>(stmt.query), false);
 
 	PivotEntryCheck("view");
 
-	if (stmt->aliases && stmt->aliases->length > 0) {
-		for (auto c = stmt->aliases->head; c != nullptr; c = lnext(c)) {
-			auto node = reinterpret_cast<duckdb_libpgquery::PGNode *>(c->data.ptr_value);
-			switch (node->type) {
+	if (stmt.aliases && stmt.aliases->length > 0) {
+		for (auto c = stmt.aliases->head; c != nullptr; c = lnext(c)) {
+			auto val = PGPointerCast<duckdb_libpgquery::PGValue>(c->data.ptr_value);
+			switch (val->type) {
 			case duckdb_libpgquery::T_PGString: {
-				auto val = (duckdb_libpgquery::PGValue *)node;
 				info->aliases.emplace_back(val->val.str);
 				break;
 			}
@@ -47,11 +42,11 @@ unique_ptr<CreateStatement> Transformer::TransformCreateView(duckdb_libpgquery::
 		}
 	}
 
-	if (stmt->options && stmt->options->length > 0) {
+	if (stmt.options && stmt.options->length > 0) {
 		throw NotImplementedException("VIEW options");
 	}
 
-	if (stmt->withCheckOption != duckdb_libpgquery::PGViewCheckOption::PG_NO_CHECK_OPTION) {
+	if (stmt.withCheckOption != duckdb_libpgquery::PGViewCheckOption::PG_NO_CHECK_OPTION) {
 		throw NotImplementedException("VIEW CHECK options");
 	}
 	result->info = std::move(info);

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

@@ -3,29 +3,27 @@
 
 namespace duckdb {
 
-unique_ptr<DeleteStatement> Transformer::TransformDelete(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGDeleteStmt *>(node);
-	D_ASSERT(stmt);
+unique_ptr<DeleteStatement> Transformer::TransformDelete(duckdb_libpgquery::PGDeleteStmt &stmt) {
 	auto result = make_uniq<DeleteStatement>();
-	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->condition = TransformExpression(stmt->whereClause);
-	result->table = TransformRangeVar(stmt->relation);
+	result->condition = TransformExpression(stmt.whereClause);
+	result->table = TransformRangeVar(*stmt.relation);
 	if (result->table->type != TableReferenceType::BASE_TABLE) {
 		throw Exception("Can only delete from base tables!");
 	}
-	if (stmt->usingClause) {
-		for (auto n = stmt->usingClause->head; n != nullptr; n = n->next) {
-			auto target = reinterpret_cast<duckdb_libpgquery::PGNode *>(n->data.ptr_value);
-			auto using_entry = TransformTableRefNode(target);
+	if (stmt.usingClause) {
+		for (auto n = stmt.usingClause->head; n != nullptr; n = n->next) {
+			auto target = PGPointerCast<duckdb_libpgquery::PGNode>(n->data.ptr_value);
+			auto using_entry = TransformTableRefNode(*target);
 			result->using_clauses.push_back(std::move(using_entry));
 		}
 	}
 
-	if (stmt->returningList) {
-		Transformer::TransformExpressionList(*(stmt->returningList), result->returning_list);
+	if (stmt.returningList) {
+		TransformExpressionList(*stmt.returningList, result->returning_list);
 	}
 	return result;
 }