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

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

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_database.cpp

@@ -6,14 +6,13 @@
 
 namespace duckdb {
 
-unique_ptr<CreateStatement> Transformer::TransformCreateDatabase(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGCreateDatabaseStmt *>(node);
+unique_ptr<CreateStatement> Transformer::TransformCreateDatabase(duckdb_libpgquery::PGCreateDatabaseStmt &stmt) {
 	auto result = make_uniq<CreateStatement>();
 	auto info = make_uniq<CreateDatabaseInfo>();
 
-	info->path = stmt->path ? stmt->path : string();
+	info->path = stmt.path ? stmt.path : string();
 
-	auto qualified_name = TransformQualifiedName(stmt->name);
+	auto qualified_name = TransformQualifiedName(*stmt.name);
 	if (!IsInvalidCatalog(qualified_name.catalog)) {
 		throw ParserException("Expected \"CREATE DATABASE database\" ");
 	}

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: