duckdb 0.8.1-dev31.0 → 0.8.1-dev341.0

package/src/duckdb/src/parser/tableref/pivotref.cpp

@@ -269,40 +269,35 @@ string PivotRef::ToString() const {
 	return result;
 }
 
-bool PivotRef::Equals(const TableRef *other_p) const {
+bool PivotRef::Equals(const TableRef &other_p) const {
 	if (!TableRef::Equals(other_p)) {
 		return false;
 	}
-	auto other = (PivotRef *)other_p;
-	if (!source->Equals(other->source.get())) {
+	auto &other = other_p.Cast<PivotRef>();
+	if (!source->Equals(*other.source)) {
 		return false;
 	}
-	if (aggregates.size() != other->aggregates.size()) {
+	if (!ParsedExpression::ListEquals(aggregates, other.aggregates)) {
 		return false;
 	}
-	for (idx_t i = 0; i < aggregates.size(); i++) {
-		if (!BaseExpression::Equals(aggregates[i].get(), other->aggregates[i].get())) {
-			return false;
-		}
-	}
-	if (pivots.size() != other->pivots.size()) {
+	if (pivots.size() != other.pivots.size()) {
 		return false;
 	}
 	for (idx_t i = 0; i < pivots.size(); i++) {
-		if (!pivots[i].Equals(other->pivots[i])) {
+		if (!pivots[i].Equals(other.pivots[i])) {
 			return false;
 		}
 	}
-	if (unpivot_names != other->unpivot_names) {
+	if (unpivot_names != other.unpivot_names) {
 		return false;
 	}
-	if (alias != other->alias) {
+	if (alias != other.alias) {
 		return false;
 	}
-	if (groups != other->groups) {
+	if (groups != other.groups) {
 		return false;
 	}
-	if (include_nulls != other->include_nulls) {
+	if (include_nulls != other.include_nulls) {
 		return false;
 	}
 	return true;

package/src/duckdb/src/parser/tableref/subqueryref.cpp

@@ -17,12 +17,12 @@ SubqueryRef::SubqueryRef(unique_ptr<SelectStatement> subquery_p, string alias_p)
 	this->alias = std::move(alias_p);
 }
 
-bool SubqueryRef::Equals(const TableRef *other_p) const {
+bool SubqueryRef::Equals(const TableRef &other_p) const {
 	if (!TableRef::Equals(other_p)) {
 		return false;
 	}
-	auto other = (SubqueryRef *)other_p;
-	return subquery->Equals(other->subquery.get());
+	auto &other = other_p.Cast<SubqueryRef>();
+	return subquery->Equals(*other.subquery);
 }
 
 unique_ptr<TableRef> SubqueryRef::Copy() {

package/src/duckdb/src/parser/tableref/table_function.cpp

@@ -13,12 +13,12 @@ string TableFunctionRef::ToString() const {
 	return BaseToString(function->ToString(), column_name_alias);
 }
 
-bool TableFunctionRef::Equals(const TableRef *other_p) const {
+bool TableFunctionRef::Equals(const TableRef &other_p) const {
 	if (!TableRef::Equals(other_p)) {
 		return false;
 	}
-	auto other = (TableFunctionRef *)other_p;
-	return function->Equals(other->function.get());
+	auto &other = other_p.Cast<TableFunctionRef>();
+	return function->Equals(*other.function);
 }
 
 void TableFunctionRef::Serialize(FieldWriter &writer) const {

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

@@ -40,9 +40,8 @@ string TableRef::BaseToString(string result, const vector<string> &column_name_a
 	return result;
 }
 
-bool TableRef::Equals(const TableRef *other) const {
-	return other && type == other->type && alias == other->alias &&
-	       SampleOptions::Equals(sample.get(), other->sample.get());
+bool TableRef::Equals(const TableRef &other) const {
+	return type == other.type && alias == other.alias && SampleOptions::Equals(sample.get(), other.sample.get());
 }
 
 void TableRef::Serialize(Serializer &serializer) const {
@@ -149,4 +148,14 @@ void TableRef::Print() {
 	Printer::Print(ToString());
 }
 
+bool TableRef::Equals(const unique_ptr<TableRef> &left, const unique_ptr<TableRef> &right) {
+	if (left.get() == right.get()) {
+		return true;
+	}
+	if (!left || !right) {
+		return false;
+	}
+	return left->Equals(*right);
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/transform/expression/transform_array_access.cpp

@@ -6,23 +6,23 @@
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformArrayAccess(duckdb_libpgquery::PGAIndirection *indirection_node) {
+unique_ptr<ParsedExpression> Transformer::TransformArrayAccess(duckdb_libpgquery::PGAIndirection &indirection_node) {
 	// transform the source expression
 	unique_ptr<ParsedExpression> result;
-	result = TransformExpression(indirection_node->arg);
+	result = TransformExpression(indirection_node.arg);
 
 	// now go over the indices
 	// note that a single indirection node can contain multiple indices
 	// this happens for e.g. more complex accesses (e.g. (foo).field1[42])
 	idx_t list_size = 0;
-	for (auto node = indirection_node->indirection->head; node != nullptr; node = node->next) {
+	for (auto node = indirection_node.indirection->head; node != nullptr; node = node->next) {
 		auto target = reinterpret_cast<duckdb_libpgquery::PGNode *>(node->data.ptr_value);
 		D_ASSERT(target);
 
 		switch (target->type) {
 		case duckdb_libpgquery::T_PGAIndices: {
 			// index access (either slice or extract)
-			auto index = (duckdb_libpgquery::PGAIndices *)target;
+			auto index = PGPointerCast<duckdb_libpgquery::PGAIndices>(target);
 			vector<unique_ptr<ParsedExpression>> children;
 			children.push_back(std::move(result));
 			if (index->is_slice) {
@@ -42,7 +42,7 @@ unique_ptr<ParsedExpression> Transformer::TransformArrayAccess(duckdb_libpgquery
 			break;
 		}
 		case duckdb_libpgquery::T_PGString: {
-			auto val = (duckdb_libpgquery::PGValue *)target;
+			auto val = PGPointerCast<duckdb_libpgquery::PGValue>(target);
 			vector<unique_ptr<ParsedExpression>> children;
 			children.push_back(std::move(result));
 			children.push_back(TransformValue(*val));
@@ -50,8 +50,8 @@ unique_ptr<ParsedExpression> Transformer::TransformArrayAccess(duckdb_libpgquery
 			break;
 		}
 		case duckdb_libpgquery::T_PGFuncCall: {
-			auto func = (duckdb_libpgquery::PGFuncCall *)target;
-			auto function = TransformFuncCall(func);
+			auto func = PGPointerCast<duckdb_libpgquery::PGFuncCall>(target);
+			auto function = TransformFuncCall(*func);
 			if (function->type != ExpressionType::FUNCTION) {
 				throw ParserException("%s.%s() call must be a function", result->ToString(), function->ToString());
 			}

package/src/duckdb/src/parser/transform/expression/transform_bool_expr.cpp

@@ -4,12 +4,12 @@
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformBoolExpr(duckdb_libpgquery::PGBoolExpr *root) {
+unique_ptr<ParsedExpression> Transformer::TransformBoolExpr(duckdb_libpgquery::PGBoolExpr &root) {
 	unique_ptr<ParsedExpression> result;
-	for (auto node = root->args->head; node != nullptr; node = node->next) {
-		auto next = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(node->data.ptr_value));
+	for (auto node = root.args->head; node != nullptr; node = node->next) {
+		auto next = TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(node->data.ptr_value));
 
-		switch (root->boolop) {
+		switch (root.boolop) {
 		case duckdb_libpgquery::PG_AND_EXPR: {
 			if (!result) {
 				result = std::move(next);

package/src/duckdb/src/parser/transform/expression/transform_boolean_test.cpp

@@ -6,15 +6,15 @@
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformBooleanTest(duckdb_libpgquery::PGBooleanTest *node) {
-	auto argument = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(node->arg));
+unique_ptr<ParsedExpression> Transformer::TransformBooleanTest(duckdb_libpgquery::PGBooleanTest &node) {
+	auto argument = TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(node.arg));
 
 	auto expr_true = make_uniq<ConstantExpression>(Value::BOOLEAN(true));
 	auto expr_false = make_uniq<ConstantExpression>(Value::BOOLEAN(false));
 	// we cast the argument to bool to remove ambiguity wrt function binding on the comparision
 	auto cast_argument = make_uniq<CastExpression>(LogicalType::BOOLEAN, argument->Copy());
 
-	switch (node->booltesttype) {
+	switch (node.booltesttype) {
 	case duckdb_libpgquery::PGBoolTestType::PG_IS_TRUE:
 		return make_uniq<ComparisonExpression>(ExpressionType::COMPARE_NOT_DISTINCT_FROM, std::move(cast_argument),
 		                                       std::move(expr_true));
@@ -32,7 +32,7 @@ unique_ptr<ParsedExpression> Transformer::TransformBooleanTest(duckdb_libpgquery
 	case duckdb_libpgquery::PGBoolTestType::IS_NOT_UNKNOWN: // IS NOT NULL
 		return make_uniq<OperatorExpression>(ExpressionType::OPERATOR_IS_NOT_NULL, std::move(argument));
 	default:
-		throw NotImplementedException("Unknown boolean test type %d", node->booltesttype);
+		throw NotImplementedException("Unknown boolean test type %d", node.booltesttype);
 	}
 }
 

package/src/duckdb/src/parser/transform/expression/transform_case.cpp

@@ -5,16 +5,14 @@
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformCase(duckdb_libpgquery::PGCaseExpr *root) {
-	D_ASSERT(root);
-
+unique_ptr<ParsedExpression> Transformer::TransformCase(duckdb_libpgquery::PGCaseExpr &root) {
 	auto case_node = make_uniq<CaseExpression>();
-	auto root_arg = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(root->arg));
-	for (auto cell = root->args->head; cell != nullptr; cell = cell->next) {
+	auto root_arg = TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(root.arg));
+	for (auto cell = root.args->head; cell != nullptr; cell = cell->next) {
 		CaseCheck case_check;
 
-		auto w = reinterpret_cast<duckdb_libpgquery::PGCaseWhen *>(cell->data.ptr_value);
-		auto test_raw = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(w->expr));
+		auto w = PGPointerCast<duckdb_libpgquery::PGCaseWhen>(cell->data.ptr_value);
+		auto test_raw = TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(w->expr));
 		unique_ptr<ParsedExpression> test;
 		if (root_arg) {
 			case_check.when_expr =
@@ -22,12 +20,12 @@ unique_ptr<ParsedExpression> Transformer::TransformCase(duckdb_libpgquery::PGCas
 		} else {
 			case_check.when_expr = std::move(test_raw);
 		}
-		case_check.then_expr = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(w->result));
+		case_check.then_expr = TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(w->result));
 		case_node->case_checks.push_back(std::move(case_check));
 	}
 
-	if (root->defresult) {
-		case_node->else_expr = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(root->defresult));
+	if (root.defresult) {
+		case_node->else_expr = TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(root.defresult));
 	} else {
 		case_node->else_expr = make_uniq<ConstantExpression>(Value(LogicalType::SQLNULL));
 	}

package/src/duckdb/src/parser/transform/expression/transform_cast.cpp

@@ -6,23 +6,21 @@
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformTypeCast(duckdb_libpgquery::PGTypeCast *root) {
-	D_ASSERT(root);
-
+unique_ptr<ParsedExpression> Transformer::TransformTypeCast(duckdb_libpgquery::PGTypeCast &root) {
 	// get the type to cast to
-	auto type_name = root->typeName;
-	LogicalType target_type = TransformTypeName(type_name);
+	auto type_name = root.typeName;
+	LogicalType target_type = TransformTypeName(*type_name);
 
 	// check for a constant BLOB value, then return ConstantExpression with BLOB
-	if (!root->tryCast && target_type == LogicalType::BLOB && root->arg->type == duckdb_libpgquery::T_PGAConst) {
-		auto c = reinterpret_cast<duckdb_libpgquery::PGAConst *>(root->arg);
+	if (!root.tryCast && target_type == LogicalType::BLOB && root.arg->type == duckdb_libpgquery::T_PGAConst) {
+		auto c = PGPointerCast<duckdb_libpgquery::PGAConst>(root.arg);
 		if (c->val.type == duckdb_libpgquery::T_PGString) {
 			return make_uniq<ConstantExpression>(Value::BLOB(string(c->val.val.str)));
 		}
 	}
 	// transform the expression node
-	auto expression = TransformExpression(root->arg);
-	bool try_cast = root->tryCast;
+	auto expression = TransformExpression(root.arg);
+	bool try_cast = root.tryCast;
 
 	// now create a cast operation
 	return make_uniq<CastExpression>(target_type, std::move(expression), try_cast);

package/src/duckdb/src/parser/transform/expression/transform_coalesce.cpp

@@ -5,16 +5,14 @@ namespace duckdb {
 
 // COALESCE(a,b,c) returns the first argument that is NOT NULL, so
 // rewrite into CASE(a IS NOT NULL, a, CASE(b IS NOT NULL, b, c))
-unique_ptr<ParsedExpression> Transformer::TransformCoalesce(duckdb_libpgquery::PGAExpr *root) {
-	D_ASSERT(root);
-
-	auto coalesce_args = reinterpret_cast<duckdb_libpgquery::PGList *>(root->lexpr);
+unique_ptr<ParsedExpression> Transformer::TransformCoalesce(duckdb_libpgquery::PGAExpr &root) {
+	auto coalesce_args = PGPointerCast<duckdb_libpgquery::PGList>(root.lexpr);
 	D_ASSERT(coalesce_args->length > 0); // parser ensures this already
 
 	auto coalesce_op = make_uniq<OperatorExpression>(ExpressionType::OPERATOR_COALESCE);
 	for (auto cell = coalesce_args->head; cell; cell = cell->next) {
 		// get the value of the COALESCE
-		auto value_expr = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(cell->data.ptr_value));
+		auto value_expr = TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(cell->data.ptr_value));
 		coalesce_op->children.push_back(std::move(value_expr));
 	}
 	return std::move(coalesce_op);

package/src/duckdb/src/parser/transform/expression/transform_columnref.cpp

@@ -6,12 +6,11 @@
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformStarExpression(duckdb_libpgquery::PGNode *node) {
-	auto star = (duckdb_libpgquery::PGAStar *)node;
-	auto result = make_uniq<StarExpression>(star->relation ? star->relation : string());
-	if (star->except_list) {
-		for (auto head = star->except_list->head; head; head = head->next) {
-			auto value = (duckdb_libpgquery::PGValue *)head->data.ptr_value;
+unique_ptr<ParsedExpression> Transformer::TransformStarExpression(duckdb_libpgquery::PGAStar &star) {
+	auto result = make_uniq<StarExpression>(star.relation ? star.relation : string());
+	if (star.except_list) {
+		for (auto head = star.except_list->head; head; head = head->next) {
+			auto value = PGPointerCast<duckdb_libpgquery::PGValue>(head->data.ptr_value);
 			D_ASSERT(value->type == duckdb_libpgquery::T_PGString);
 			string exclude_entry = value->val.str;
 			if (result->exclude_list.find(exclude_entry) != result->exclude_list.end()) {
@@ -20,12 +19,13 @@ unique_ptr<ParsedExpression> Transformer::TransformStarExpression(duckdb_libpgqu
 			result->exclude_list.insert(std::move(exclude_entry));
 		}
 	}
-	if (star->replace_list) {
-		for (auto head = star->replace_list->head; head; head = head->next) {
-			auto list = (duckdb_libpgquery::PGList *)head->data.ptr_value;
+	if (star.replace_list) {
+		for (auto head = star.replace_list->head; head; head = head->next) {
+			auto list = PGPointerCast<duckdb_libpgquery::PGList>(head->data.ptr_value);
 			D_ASSERT(list->length == 2);
-			auto replace_expression = TransformExpression((duckdb_libpgquery::PGNode *)list->head->data.ptr_value);
-			auto value = (duckdb_libpgquery::PGValue *)list->tail->data.ptr_value;
+			auto replace_expression =
+			    TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(list->head->data.ptr_value));
+			auto value = PGPointerCast<duckdb_libpgquery::PGValue>(list->tail->data.ptr_value);
 			D_ASSERT(value->type == duckdb_libpgquery::T_PGString);
 			string exclude_entry = value->val.str;
 			if (result->replace_list.find(exclude_entry) != result->replace_list.end()) {
@@ -37,12 +37,12 @@ unique_ptr<ParsedExpression> Transformer::TransformStarExpression(duckdb_libpgqu
 			result->replace_list.insert(make_pair(std::move(exclude_entry), std::move(replace_expression)));
 		}
 	}
-	if (star->expr) {
-		D_ASSERT(star->columns);
+	if (star.expr) {
+		D_ASSERT(star.columns);
 		D_ASSERT(result->relation_name.empty());
 		D_ASSERT(result->exclude_list.empty());
 		D_ASSERT(result->replace_list.empty());
-		result->expr = TransformExpression(star->expr);
+		result->expr = TransformExpression(star.expr);
 		if (result->expr->type == ExpressionType::STAR) {
 			auto &child_star = result->expr->Cast<StarExpression>();
 			result->exclude_list = std::move(child_star.exclude_list);
@@ -56,14 +56,14 @@ unique_ptr<ParsedExpression> Transformer::TransformStarExpression(duckdb_libpgqu
 			result->expr = std::move(list_filter);
 		}
 	}
-	result->columns = star->columns;
-	result->query_location = star->location;
+	result->columns = star.columns;
+	result->query_location = star.location;
 	return std::move(result);
 }
 
-unique_ptr<ParsedExpression> Transformer::TransformColumnRef(duckdb_libpgquery::PGColumnRef *root) {
-	auto fields = root->fields;
-	auto head_node = (duckdb_libpgquery::PGNode *)fields->head->data.ptr_value;
+unique_ptr<ParsedExpression> Transformer::TransformColumnRef(duckdb_libpgquery::PGColumnRef &root) {
+	auto fields = root.fields;
+	auto head_node = PGPointerCast<duckdb_libpgquery::PGNode>(fields->head->data.ptr_value);
 	switch (head_node->type) {
 	case duckdb_libpgquery::T_PGString: {
 		if (fields->length < 1) {
@@ -71,14 +71,14 @@ unique_ptr<ParsedExpression> Transformer::TransformColumnRef(duckdb_libpgquery::
 		}
 		vector<string> column_names;
 		for (auto node = fields->head; node; node = node->next) {
-			column_names.emplace_back(reinterpret_cast<duckdb_libpgquery::PGValue *>(node->data.ptr_value)->val.str);
+			column_names.emplace_back(PGPointerCast<duckdb_libpgquery::PGValue>(node->data.ptr_value)->val.str);
 		}
 		auto colref = make_uniq<ColumnRefExpression>(std::move(column_names));
-		colref->query_location = root->location;
+		colref->query_location = root.location;
 		return std::move(colref);
 	}
 	case duckdb_libpgquery::T_PGAStar: {
-		return TransformStarExpression(head_node);
+		return TransformStarExpression(PGCast<duckdb_libpgquery::PGAStar>(*head_node));
 	}
 	default:
 		throw NotImplementedException("ColumnRef not implemented!");

package/src/duckdb/src/parser/transform/expression/transform_constant.cpp

@@ -72,8 +72,8 @@ unique_ptr<ConstantExpression> Transformer::TransformValue(duckdb_libpgquery::PG
 	}
 }
 
-unique_ptr<ParsedExpression> Transformer::TransformConstant(duckdb_libpgquery::PGAConst *c) {
-	return TransformValue(c->val);
+unique_ptr<ParsedExpression> Transformer::TransformConstant(duckdb_libpgquery::PGAConst &c) {
+	return TransformValue(c.val);
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/transform/expression/transform_expression.cpp

@@ -4,98 +4,96 @@
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformResTarget(duckdb_libpgquery::PGResTarget *root) {
-	D_ASSERT(root);
-
-	auto expr = TransformExpression(root->val);
+unique_ptr<ParsedExpression> Transformer::TransformResTarget(duckdb_libpgquery::PGResTarget &root) {
+	auto expr = TransformExpression(root.val);
 	if (!expr) {
 		return nullptr;
 	}
-	if (root->name) {
-		expr->alias = string(root->name);
+	if (root.name) {
+		expr->alias = string(root.name);
 	}
 	return expr;
 }
 
-unique_ptr<ParsedExpression> Transformer::TransformNamedArg(duckdb_libpgquery::PGNamedArgExpr *root) {
-	D_ASSERT(root);
+unique_ptr<ParsedExpression> Transformer::TransformNamedArg(duckdb_libpgquery::PGNamedArgExpr &root) {
 
-	auto expr = TransformExpression((duckdb_libpgquery::PGNode *)root->arg);
-	if (root->name) {
-		expr->alias = string(root->name);
+	auto expr = TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(root.arg));
+	if (root.name) {
+		expr->alias = string(root.name);
 	}
 	return expr;
 }
 
-unique_ptr<ParsedExpression> Transformer::TransformExpression(duckdb_libpgquery::PGNode *node) {
-	if (!node) {
-		return nullptr;
-	}
+unique_ptr<ParsedExpression> Transformer::TransformExpression(duckdb_libpgquery::PGNode &node) {
 
 	auto stack_checker = StackCheck();
 
-	switch (node->type) {
+	switch (node.type) {
 	case duckdb_libpgquery::T_PGColumnRef:
-		return TransformColumnRef(reinterpret_cast<duckdb_libpgquery::PGColumnRef *>(node));
+		return TransformColumnRef(PGCast<duckdb_libpgquery::PGColumnRef>(node));
 	case duckdb_libpgquery::T_PGAConst:
-		return TransformConstant(reinterpret_cast<duckdb_libpgquery::PGAConst *>(node));
+		return TransformConstant(PGCast<duckdb_libpgquery::PGAConst>(node));
 	case duckdb_libpgquery::T_PGAExpr:
-		return TransformAExpr(reinterpret_cast<duckdb_libpgquery::PGAExpr *>(node));
+		return TransformAExpr(PGCast<duckdb_libpgquery::PGAExpr>(node));
 	case duckdb_libpgquery::T_PGFuncCall:
-		return TransformFuncCall(reinterpret_cast<duckdb_libpgquery::PGFuncCall *>(node));
+		return TransformFuncCall(PGCast<duckdb_libpgquery::PGFuncCall>(node));
 	case duckdb_libpgquery::T_PGBoolExpr:
-		return TransformBoolExpr(reinterpret_cast<duckdb_libpgquery::PGBoolExpr *>(node));
+		return TransformBoolExpr(PGCast<duckdb_libpgquery::PGBoolExpr>(node));
 	case duckdb_libpgquery::T_PGTypeCast:
-		return TransformTypeCast(reinterpret_cast<duckdb_libpgquery::PGTypeCast *>(node));
+		return TransformTypeCast(PGCast<duckdb_libpgquery::PGTypeCast>(node));
 	case duckdb_libpgquery::T_PGCaseExpr:
-		return TransformCase(reinterpret_cast<duckdb_libpgquery::PGCaseExpr *>(node));
+		return TransformCase(PGCast<duckdb_libpgquery::PGCaseExpr>(node));
 	case duckdb_libpgquery::T_PGSubLink:
-		return TransformSubquery(reinterpret_cast<duckdb_libpgquery::PGSubLink *>(node));
+		return TransformSubquery(PGCast<duckdb_libpgquery::PGSubLink>(node));
 	case duckdb_libpgquery::T_PGCoalesceExpr:
-		return TransformCoalesce(reinterpret_cast<duckdb_libpgquery::PGAExpr *>(node));
+		return TransformCoalesce(PGCast<duckdb_libpgquery::PGAExpr>(node));
 	case duckdb_libpgquery::T_PGNullTest:
-		return TransformNullTest(reinterpret_cast<duckdb_libpgquery::PGNullTest *>(node));
+		return TransformNullTest(PGCast<duckdb_libpgquery::PGNullTest>(node));
 	case duckdb_libpgquery::T_PGResTarget:
-		return TransformResTarget(reinterpret_cast<duckdb_libpgquery::PGResTarget *>(node));
+		return TransformResTarget(PGCast<duckdb_libpgquery::PGResTarget>(node));
 	case duckdb_libpgquery::T_PGParamRef:
-		return TransformParamRef(reinterpret_cast<duckdb_libpgquery::PGParamRef *>(node));
+		return TransformParamRef(PGCast<duckdb_libpgquery::PGParamRef>(node));
 	case duckdb_libpgquery::T_PGNamedArgExpr:
-		return TransformNamedArg(reinterpret_cast<duckdb_libpgquery::PGNamedArgExpr *>(node));
+		return TransformNamedArg(PGCast<duckdb_libpgquery::PGNamedArgExpr>(node));
 	case duckdb_libpgquery::T_PGSQLValueFunction:
-		return TransformSQLValueFunction(reinterpret_cast<duckdb_libpgquery::PGSQLValueFunction *>(node));
+		return TransformSQLValueFunction(PGCast<duckdb_libpgquery::PGSQLValueFunction>(node));
 	case duckdb_libpgquery::T_PGSetToDefault:
 		return make_uniq<DefaultExpression>();
 	case duckdb_libpgquery::T_PGCollateClause:
-		return TransformCollateExpr(reinterpret_cast<duckdb_libpgquery::PGCollateClause *>(node));
+		return TransformCollateExpr(PGCast<duckdb_libpgquery::PGCollateClause>(node));
 	case duckdb_libpgquery::T_PGIntervalConstant:
-		return TransformInterval(reinterpret_cast<duckdb_libpgquery::PGIntervalConstant *>(node));
+		return TransformInterval(PGCast<duckdb_libpgquery::PGIntervalConstant>(node));
 	case duckdb_libpgquery::T_PGLambdaFunction:
-		return TransformLambda(reinterpret_cast<duckdb_libpgquery::PGLambdaFunction *>(node));
+		return TransformLambda(PGCast<duckdb_libpgquery::PGLambdaFunction>(node));
 	case duckdb_libpgquery::T_PGAIndirection:
-		return TransformArrayAccess(reinterpret_cast<duckdb_libpgquery::PGAIndirection *>(node));
+		return TransformArrayAccess(PGCast<duckdb_libpgquery::PGAIndirection>(node));
 	case duckdb_libpgquery::T_PGPositionalReference:
-		return TransformPositionalReference(reinterpret_cast<duckdb_libpgquery::PGPositionalReference *>(node));
+		return TransformPositionalReference(PGCast<duckdb_libpgquery::PGPositionalReference>(node));
 	case duckdb_libpgquery::T_PGGroupingFunc:
-		return TransformGroupingFunction(reinterpret_cast<duckdb_libpgquery::PGGroupingFunc *>(node));
+		return TransformGroupingFunction(PGCast<duckdb_libpgquery::PGGroupingFunc>(node));
 	case duckdb_libpgquery::T_PGAStar:
-		return TransformStarExpression(node);
+		return TransformStarExpression(PGCast<duckdb_libpgquery::PGAStar>(node));
 	case duckdb_libpgquery::T_PGBooleanTest:
-		return TransformBooleanTest(reinterpret_cast<duckdb_libpgquery::PGBooleanTest *>(node));
+		return TransformBooleanTest(PGCast<duckdb_libpgquery::PGBooleanTest>(node));
 
 	default:
-		throw NotImplementedException("Expression type %s (%d)", NodetypeToString(node->type), (int)node->type);
+		throw NotImplementedException("Expression type %s (%d)", NodetypeToString(node.type), (int)node.type);
+	}
+}
+
+unique_ptr<ParsedExpression> Transformer::TransformExpression(optional_ptr<duckdb_libpgquery::PGNode> node) {
+	if (!node) {
+		return nullptr;
 	}
+	return TransformExpression(*node);
 }
 
 void Transformer::TransformExpressionList(duckdb_libpgquery::PGList &list,
                                           vector<unique_ptr<ParsedExpression>> &result) {
 	for (auto node = list.head; node != nullptr; node = node->next) {
-		auto target = reinterpret_cast<duckdb_libpgquery::PGNode *>(node->data.ptr_value);
-		D_ASSERT(target);
-
-		auto expr = TransformExpression(target);
-		D_ASSERT(expr);
+		auto target = PGPointerCast<duckdb_libpgquery::PGNode>(node->data.ptr_value);
 
+		auto expr = TransformExpression(*target);
 		result.push_back(std::move(expr));
 	}
 }