duckdb 0.8.1-dev23.0 → 0.8.1-dev253.0

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

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

@@ -5,12 +5,11 @@
 
 namespace duckdb {
 
-unique_ptr<DetachStatement> Transformer::TransformDetach(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGDetachStmt *>(node);
+unique_ptr<DetachStatement> Transformer::TransformDetach(duckdb_libpgquery::PGDetachStmt &stmt) {
 	auto result = make_uniq<DetachStatement>();
 	auto info = make_uniq<DetachInfo>();
-	info->name = stmt->db_name;
-	info->if_not_found = TransformOnEntryNotFound(stmt->missing_ok);
+	info->name = stmt.db_name;
+	info->if_not_found = TransformOnEntryNotFound(stmt.missing_ok);
 
 	result->info = std::move(info);
 	return result;

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

@@ -3,15 +3,13 @@
 
 namespace duckdb {
 
-unique_ptr<SQLStatement> Transformer::TransformDrop(duckdb_libpgquery::PGNode *node) {
-	auto stmt = (duckdb_libpgquery::PGDropStmt *)(node);
+unique_ptr<SQLStatement> Transformer::TransformDrop(duckdb_libpgquery::PGDropStmt &stmt) {
 	auto result = make_uniq<DropStatement>();
 	auto &info = *result->info.get();
-	D_ASSERT(stmt);
-	if (stmt->objects->length != 1) {
+	if (stmt.objects->length != 1) {
 		throw NotImplementedException("Can only drop one object at a time");
 	}
-	switch (stmt->removeType) {
+	switch (stmt.removeType) {
 	case duckdb_libpgquery::PG_OBJECT_TABLE:
 		info.type = CatalogType::TABLE_ENTRY;
 		break;
@@ -43,44 +41,44 @@ unique_ptr<SQLStatement> Transformer::TransformDrop(duckdb_libpgquery::PGNode *n
 		throw NotImplementedException("Cannot drop this type yet");
 	}
 
-	switch (stmt->removeType) {
+	switch (stmt.removeType) {
 	case duckdb_libpgquery::PG_OBJECT_TYPE: {
-		auto view_list = (duckdb_libpgquery::PGList *)stmt->objects;
-		auto target = (duckdb_libpgquery::PGTypeName *)(view_list->head->data.ptr_value);
-		info.name = (reinterpret_cast<duckdb_libpgquery::PGValue *>(target->names->tail->data.ptr_value)->val.str);
+		auto view_list = PGPointerCast<duckdb_libpgquery::PGList>(stmt.objects);
+		auto target = PGPointerCast<duckdb_libpgquery::PGTypeName>(view_list->head->data.ptr_value);
+		info.name = PGPointerCast<duckdb_libpgquery::PGValue>(target->names->tail->data.ptr_value)->val.str;
 		break;
 	}
 	case duckdb_libpgquery::PG_OBJECT_SCHEMA: {
-		auto view_list = (duckdb_libpgquery::PGList *)stmt->objects->head->data.ptr_value;
+		auto view_list = PGPointerCast<duckdb_libpgquery::PGList>(stmt.objects->head->data.ptr_value);
 		if (view_list->length == 2) {
-			info.catalog = ((duckdb_libpgquery::PGValue *)view_list->head->data.ptr_value)->val.str;
-			info.name = ((duckdb_libpgquery::PGValue *)view_list->head->next->data.ptr_value)->val.str;
+			info.catalog = PGPointerCast<duckdb_libpgquery::PGValue>(view_list->head->data.ptr_value)->val.str;
+			info.name = PGPointerCast<duckdb_libpgquery::PGValue>(view_list->head->next->data.ptr_value)->val.str;
 		} else if (view_list->length == 1) {
-			info.name = ((duckdb_libpgquery::PGValue *)view_list->head->data.ptr_value)->val.str;
+			info.name = PGPointerCast<duckdb_libpgquery::PGValue>(view_list->head->data.ptr_value)->val.str;
 		} else {
 			throw ParserException("Expected \"catalog.schema\" or \"schema\"");
 		}
 		break;
 	}
 	default: {
-		auto view_list = (duckdb_libpgquery::PGList *)stmt->objects->head->data.ptr_value;
+		auto view_list = PGPointerCast<duckdb_libpgquery::PGList>(stmt.objects->head->data.ptr_value);
 		if (view_list->length == 3) {
-			info.catalog = ((duckdb_libpgquery::PGValue *)view_list->head->data.ptr_value)->val.str;
-			info.schema = ((duckdb_libpgquery::PGValue *)view_list->head->next->data.ptr_value)->val.str;
-			info.name = ((duckdb_libpgquery::PGValue *)view_list->head->next->next->data.ptr_value)->val.str;
+			info.catalog = PGPointerCast<duckdb_libpgquery::PGValue>(view_list->head->data.ptr_value)->val.str;
+			info.schema = PGPointerCast<duckdb_libpgquery::PGValue>(view_list->head->next->data.ptr_value)->val.str;
+			info.name = PGPointerCast<duckdb_libpgquery::PGValue>(view_list->head->next->next->data.ptr_value)->val.str;
 		} else if (view_list->length == 2) {
-			info.schema = ((duckdb_libpgquery::PGValue *)view_list->head->data.ptr_value)->val.str;
-			info.name = ((duckdb_libpgquery::PGValue *)view_list->head->next->data.ptr_value)->val.str;
+			info.schema = PGPointerCast<duckdb_libpgquery::PGValue>(view_list->head->data.ptr_value)->val.str;
+			info.name = PGPointerCast<duckdb_libpgquery::PGValue>(view_list->head->next->data.ptr_value)->val.str;
 		} else if (view_list->length == 1) {
-			info.name = ((duckdb_libpgquery::PGValue *)view_list->head->data.ptr_value)->val.str;
+			info.name = PGPointerCast<duckdb_libpgquery::PGValue>(view_list->head->data.ptr_value)->val.str;
 		} else {
 			throw ParserException("Expected \"catalog.schema.name\", \"schema.name\"or \"name\"");
 		}
 		break;
 	}
 	}
-	info.cascade = stmt->behavior == duckdb_libpgquery::PGDropBehavior::PG_DROP_CASCADE;
-	info.if_not_found = TransformOnEntryNotFound(stmt->missing_ok);
+	info.cascade = stmt.behavior == duckdb_libpgquery::PGDropBehavior::PG_DROP_CASCADE;
+	info.if_not_found = TransformOnEntryNotFound(stmt.missing_ok);
 	return std::move(result);
 }
 

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

@@ -3,13 +3,11 @@
 
 namespace duckdb {
 
-unique_ptr<ExplainStatement> Transformer::TransformExplain(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGExplainStmt *>(node);
-	D_ASSERT(stmt);
+unique_ptr<ExplainStatement> Transformer::TransformExplain(duckdb_libpgquery::PGExplainStmt &stmt) {
 	auto explain_type = ExplainType::EXPLAIN_STANDARD;
-	if (stmt->options) {
-		for (auto n = stmt->options->head; n; n = n->next) {
-			auto def_elem = ((duckdb_libpgquery::PGDefElem *)n->data.ptr_value)->defname;
+	if (stmt.options) {
+		for (auto n = stmt.options->head; n; n = n->next) {
+			auto def_elem = PGPointerCast<duckdb_libpgquery::PGDefElem>(n->data.ptr_value)->defname;
 			string elem(def_elem);
 			if (elem == "analyze") {
 				explain_type = ExplainType::EXPLAIN_ANALYZE;
@@ -18,7 +16,7 @@ unique_ptr<ExplainStatement> Transformer::TransformExplain(duckdb_libpgquery::PG
 			}
 		}
 	}
-	return make_uniq<ExplainStatement>(TransformStatement(stmt->query), explain_type);
+	return make_uniq<ExplainStatement>(TransformStatement(*stmt.query), explain_type);
 }
 
 } // namespace duckdb

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

@@ -3,18 +3,17 @@
 
 namespace duckdb {
 
-unique_ptr<ExportStatement> Transformer::TransformExport(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGExportStmt *>(node);
+unique_ptr<ExportStatement> Transformer::TransformExport(duckdb_libpgquery::PGExportStmt &stmt) {
 	auto info = make_uniq<CopyInfo>();
-	info->file_path = stmt->filename;
+	info->file_path = stmt.filename;
 	info->format = "csv";
 	info->is_from = false;
 	// handle export options
-	TransformCopyOptions(*info, stmt->options);
+	TransformCopyOptions(*info, stmt.options);
 
 	auto result = make_uniq<ExportStatement>(std::move(info));
-	if (stmt->database) {
-		result->database = stmt->database;
+	if (stmt.database) {
+		result->database = stmt.database;
 	}
 	return result;
 }

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

@@ -3,11 +3,10 @@
 
 namespace duckdb {
 
-unique_ptr<PragmaStatement> Transformer::TransformImport(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGImportStmt *>(node);
+unique_ptr<PragmaStatement> Transformer::TransformImport(duckdb_libpgquery::PGImportStmt &stmt) {
 	auto result = make_uniq<PragmaStatement>();
 	result->info->name = "import_database";
-	result->info->parameters.emplace_back(stmt->filename);
+	result->info->parameters.emplace_back(stmt.filename);
 	return result;
 }
 

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

@@ -7,7 +7,7 @@ namespace duckdb {
 unique_ptr<TableRef> Transformer::TransformValuesList(duckdb_libpgquery::PGList *list) {
 	auto result = make_uniq<ExpressionListRef>();
 	for (auto value_list = list->head; value_list != nullptr; value_list = value_list->next) {
-		auto target = (duckdb_libpgquery::PGList *)(value_list->data.ptr_value);
+		auto target = PGPointerCast<duckdb_libpgquery::PGList>(value_list->data.ptr_value);
 
 		vector<unique_ptr<ParsedExpression>> insert_values;
 		TransformExpressionList(*target, insert_values);
@@ -22,52 +22,49 @@ unique_ptr<TableRef> Transformer::TransformValuesList(duckdb_libpgquery::PGList
 	return std::move(result);
 }
 
-unique_ptr<InsertStatement> Transformer::TransformInsert(duckdb_libpgquery::PGNode *node) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGInsertStmt *>(node);
-	D_ASSERT(stmt);
-
+unique_ptr<InsertStatement> Transformer::TransformInsert(duckdb_libpgquery::PGInsertStmt &stmt) {
 	auto result = make_uniq<InsertStatement>();
-	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);
 	}
 
 	// first check if there are any columns specified
-	if (stmt->cols) {
-		for (auto c = stmt->cols->head; c != nullptr; c = lnext(c)) {
-			auto target = (duckdb_libpgquery::PGResTarget *)(c->data.ptr_value);
+	if (stmt.cols) {
+		for (auto c = stmt.cols->head; c != nullptr; c = lnext(c)) {
+			auto target = PGPointerCast<duckdb_libpgquery::PGResTarget>(c->data.ptr_value);
 			result->columns.emplace_back(target->name);
 		}
 	}
 
 	// 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);
 	}
-	if (stmt->selectStmt) {
-		result->select_statement = TransformSelect(stmt->selectStmt, false);
+	if (stmt.selectStmt) {
+		result->select_statement = TransformSelect(stmt.selectStmt, false);
 	} else {
 		result->default_values = true;
 	}
 
-	auto qname = TransformQualifiedName(stmt->relation);
+	auto qname = TransformQualifiedName(*stmt.relation);
 	result->table = qname.name;
 	result->schema = qname.schema;
 
-	if (stmt->onConflictClause) {
-		if (stmt->onConflictAlias != duckdb_libpgquery::PG_ONCONFLICT_ALIAS_NONE) {
+	if (stmt.onConflictClause) {
+		if (stmt.onConflictAlias != duckdb_libpgquery::PG_ONCONFLICT_ALIAS_NONE) {
 			// OR REPLACE | OR IGNORE are shorthands for the ON CONFLICT clause
 			throw ParserException("You can not provide both OR REPLACE|IGNORE and an ON CONFLICT clause, please remove "
 			                      "the first if you want to have more granual control");
 		}
-		result->on_conflict_info = TransformOnConflictClause(stmt->onConflictClause, result->schema);
-		result->table_ref = TransformRangeVar(stmt->relation);
+		result->on_conflict_info = TransformOnConflictClause(stmt.onConflictClause, result->schema);
+		result->table_ref = TransformRangeVar(*stmt.relation);
 	}
-	if (stmt->onConflictAlias != duckdb_libpgquery::PG_ONCONFLICT_ALIAS_NONE) {
-		D_ASSERT(!stmt->onConflictClause);
-		result->on_conflict_info = DummyOnConflictClause(stmt->onConflictAlias, result->schema);
-		result->table_ref = TransformRangeVar(stmt->relation);
+	if (stmt.onConflictAlias != duckdb_libpgquery::PG_ONCONFLICT_ALIAS_NONE) {
+		D_ASSERT(!stmt.onConflictClause);
+		result->on_conflict_info = DummyOnConflictClause(stmt.onConflictAlias, result->schema);
+		result->table_ref = TransformRangeVar(*stmt.relation);
 	}
-	switch (stmt->insert_column_order) {
+	switch (stmt.insert_column_order) {
 	case duckdb_libpgquery::PG_INSERT_BY_POSITION:
 		result->column_order = InsertColumnOrder::INSERT_BY_POSITION;
 		break;

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

@@ -3,14 +3,13 @@
 
 namespace duckdb {
 
-unique_ptr<LoadStatement> Transformer::TransformLoad(duckdb_libpgquery::PGNode *node) {
-	D_ASSERT(node->type == duckdb_libpgquery::T_PGLoadStmt);
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGLoadStmt *>(node);
+unique_ptr<LoadStatement> Transformer::TransformLoad(duckdb_libpgquery::PGLoadStmt &stmt) {
+	D_ASSERT(stmt.type == duckdb_libpgquery::T_PGLoadStmt);
 
 	auto load_stmt = make_uniq<LoadStatement>();
 	auto load_info = make_uniq<LoadInfo>();
-	load_info->filename = std::string(stmt->filename);
-	switch (stmt->load_type) {
+	load_info->filename = std::string(stmt.filename);
+	switch (stmt.load_type) {
 	case duckdb_libpgquery::PG_LOAD_TYPE_LOAD:
 		load_info->load_type = LoadType::LOAD;
 		break;