duckdb 0.8.1-dev65.0 → 0.8.1

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

@@ -13,66 +13,60 @@
 
 namespace duckdb {
 
-void Transformer::TransformWindowDef(duckdb_libpgquery::PGWindowDef *window_spec, WindowExpression *expr,
+void Transformer::TransformWindowDef(duckdb_libpgquery::PGWindowDef &window_spec, WindowExpression &expr,
                                      const char *window_name) {
-	D_ASSERT(window_spec);
-	D_ASSERT(expr);
-
 	// next: partitioning/ordering expressions
-	if (window_spec->partitionClause) {
-		if (window_name && !expr->partitions.empty()) {
+	if (window_spec.partitionClause) {
+		if (window_name && !expr.partitions.empty()) {
 			throw ParserException("Cannot override PARTITION BY clause of window \"%s\"", window_name);
 		}
-		TransformExpressionList(*window_spec->partitionClause, expr->partitions);
+		TransformExpressionList(*window_spec.partitionClause, expr.partitions);
 	}
-	if (window_spec->orderClause) {
-		if (window_name && !expr->orders.empty()) {
+	if (window_spec.orderClause) {
+		if (window_name && !expr.orders.empty()) {
 			throw ParserException("Cannot override ORDER BY clause of window \"%s\"", window_name);
 		}
-		TransformOrderBy(window_spec->orderClause, expr->orders);
+		TransformOrderBy(window_spec.orderClause, expr.orders);
 	}
 }
 
-void Transformer::TransformWindowFrame(duckdb_libpgquery::PGWindowDef *window_spec, WindowExpression *expr) {
-	D_ASSERT(window_spec);
-	D_ASSERT(expr);
-
+void Transformer::TransformWindowFrame(duckdb_libpgquery::PGWindowDef &window_spec, WindowExpression &expr) {
 	// finally: specifics of bounds
-	expr->start_expr = TransformExpression(window_spec->startOffset);
-	expr->end_expr = TransformExpression(window_spec->endOffset);
+	expr.start_expr = TransformExpression(window_spec.startOffset);
+	expr.end_expr = TransformExpression(window_spec.endOffset);
 
-	if ((window_spec->frameOptions & FRAMEOPTION_END_UNBOUNDED_PRECEDING) ||
-	    (window_spec->frameOptions & FRAMEOPTION_START_UNBOUNDED_FOLLOWING)) {
+	if ((window_spec.frameOptions & FRAMEOPTION_END_UNBOUNDED_PRECEDING) ||
+	    (window_spec.frameOptions & FRAMEOPTION_START_UNBOUNDED_FOLLOWING)) {
 		throw InternalException(
 		    "Window frames starting with unbounded following or ending in unbounded preceding make no sense");
 	}
 
-	const bool rangeMode = (window_spec->frameOptions & FRAMEOPTION_RANGE) != 0;
-	if (window_spec->frameOptions & FRAMEOPTION_START_UNBOUNDED_PRECEDING) {
-		expr->start = WindowBoundary::UNBOUNDED_PRECEDING;
-	} else if (window_spec->frameOptions & FRAMEOPTION_START_VALUE_PRECEDING) {
-		expr->start = rangeMode ? WindowBoundary::EXPR_PRECEDING_RANGE : WindowBoundary::EXPR_PRECEDING_ROWS;
-	} else if (window_spec->frameOptions & FRAMEOPTION_START_VALUE_FOLLOWING) {
-		expr->start = rangeMode ? WindowBoundary::EXPR_FOLLOWING_RANGE : WindowBoundary::EXPR_FOLLOWING_ROWS;
-	} else if (window_spec->frameOptions & FRAMEOPTION_START_CURRENT_ROW) {
-		expr->start = rangeMode ? WindowBoundary::CURRENT_ROW_RANGE : WindowBoundary::CURRENT_ROW_ROWS;
+	const bool rangeMode = (window_spec.frameOptions & FRAMEOPTION_RANGE) != 0;
+	if (window_spec.frameOptions & FRAMEOPTION_START_UNBOUNDED_PRECEDING) {
+		expr.start = WindowBoundary::UNBOUNDED_PRECEDING;
+	} else if (window_spec.frameOptions & FRAMEOPTION_START_VALUE_PRECEDING) {
+		expr.start = rangeMode ? WindowBoundary::EXPR_PRECEDING_RANGE : WindowBoundary::EXPR_PRECEDING_ROWS;
+	} else if (window_spec.frameOptions & FRAMEOPTION_START_VALUE_FOLLOWING) {
+		expr.start = rangeMode ? WindowBoundary::EXPR_FOLLOWING_RANGE : WindowBoundary::EXPR_FOLLOWING_ROWS;
+	} else if (window_spec.frameOptions & FRAMEOPTION_START_CURRENT_ROW) {
+		expr.start = rangeMode ? WindowBoundary::CURRENT_ROW_RANGE : WindowBoundary::CURRENT_ROW_ROWS;
 	}
 
-	if (window_spec->frameOptions & FRAMEOPTION_END_UNBOUNDED_FOLLOWING) {
-		expr->end = WindowBoundary::UNBOUNDED_FOLLOWING;
-	} else if (window_spec->frameOptions & FRAMEOPTION_END_VALUE_PRECEDING) {
-		expr->end = rangeMode ? WindowBoundary::EXPR_PRECEDING_RANGE : WindowBoundary::EXPR_PRECEDING_ROWS;
-	} else if (window_spec->frameOptions & FRAMEOPTION_END_VALUE_FOLLOWING) {
-		expr->end = rangeMode ? WindowBoundary::EXPR_FOLLOWING_RANGE : WindowBoundary::EXPR_FOLLOWING_ROWS;
-	} else if (window_spec->frameOptions & FRAMEOPTION_END_CURRENT_ROW) {
-		expr->end = rangeMode ? WindowBoundary::CURRENT_ROW_RANGE : WindowBoundary::CURRENT_ROW_ROWS;
+	if (window_spec.frameOptions & FRAMEOPTION_END_UNBOUNDED_FOLLOWING) {
+		expr.end = WindowBoundary::UNBOUNDED_FOLLOWING;
+	} else if (window_spec.frameOptions & FRAMEOPTION_END_VALUE_PRECEDING) {
+		expr.end = rangeMode ? WindowBoundary::EXPR_PRECEDING_RANGE : WindowBoundary::EXPR_PRECEDING_ROWS;
+	} else if (window_spec.frameOptions & FRAMEOPTION_END_VALUE_FOLLOWING) {
+		expr.end = rangeMode ? WindowBoundary::EXPR_FOLLOWING_RANGE : WindowBoundary::EXPR_FOLLOWING_ROWS;
+	} else if (window_spec.frameOptions & FRAMEOPTION_END_CURRENT_ROW) {
+		expr.end = rangeMode ? WindowBoundary::CURRENT_ROW_RANGE : WindowBoundary::CURRENT_ROW_ROWS;
 	}
 
-	D_ASSERT(expr->start != WindowBoundary::INVALID && expr->end != WindowBoundary::INVALID);
-	if (((window_spec->frameOptions & (FRAMEOPTION_START_VALUE_PRECEDING | FRAMEOPTION_START_VALUE_FOLLOWING)) &&
-	     !expr->start_expr) ||
-	    ((window_spec->frameOptions & (FRAMEOPTION_END_VALUE_PRECEDING | FRAMEOPTION_END_VALUE_FOLLOWING)) &&
-	     !expr->end_expr)) {
+	D_ASSERT(expr.start != WindowBoundary::INVALID && expr.end != WindowBoundary::INVALID);
+	if (((window_spec.frameOptions & (FRAMEOPTION_START_VALUE_PRECEDING | FRAMEOPTION_START_VALUE_FOLLOWING)) &&
+	     !expr.start_expr) ||
+	    ((window_spec.frameOptions & (FRAMEOPTION_END_VALUE_PRECEDING | FRAMEOPTION_END_VALUE_FOLLOWING)) &&
+	     !expr.end_expr)) {
 		throw InternalException("Failed to transform window boundary expression");
 	}
 }
@@ -98,40 +92,40 @@ bool Transformer::InWindowDefinition() {
 	return false;
 }
 
-unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::PGFuncCall *root) {
-	auto name = root->funcname;
+unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::PGFuncCall &root) {
+	auto name = root.funcname;
 	string catalog, schema, function_name;
 	if (name->length == 3) {
 		// catalog + schema + name
-		catalog = reinterpret_cast<duckdb_libpgquery::PGValue *>(name->head->data.ptr_value)->val.str;
-		schema = reinterpret_cast<duckdb_libpgquery::PGValue *>(name->head->next->data.ptr_value)->val.str;
-		function_name = reinterpret_cast<duckdb_libpgquery::PGValue *>(name->head->next->next->data.ptr_value)->val.str;
+		catalog = PGPointerCast<duckdb_libpgquery::PGValue>(name->head->data.ptr_value)->val.str;
+		schema = PGPointerCast<duckdb_libpgquery::PGValue>(name->head->next->data.ptr_value)->val.str;
+		function_name = PGPointerCast<duckdb_libpgquery::PGValue>(name->head->next->next->data.ptr_value)->val.str;
 	} else if (name->length == 2) {
 		// schema + name
 		catalog = INVALID_CATALOG;
-		schema = reinterpret_cast<duckdb_libpgquery::PGValue *>(name->head->data.ptr_value)->val.str;
-		function_name = reinterpret_cast<duckdb_libpgquery::PGValue *>(name->head->next->data.ptr_value)->val.str;
+		schema = PGPointerCast<duckdb_libpgquery::PGValue>(name->head->data.ptr_value)->val.str;
+		function_name = PGPointerCast<duckdb_libpgquery::PGValue>(name->head->next->data.ptr_value)->val.str;
 	} else if (name->length == 1) {
 		// unqualified name
 		catalog = INVALID_CATALOG;
 		schema = INVALID_SCHEMA;
-		function_name = reinterpret_cast<duckdb_libpgquery::PGValue *>(name->head->data.ptr_value)->val.str;
+		function_name = PGPointerCast<duckdb_libpgquery::PGValue>(name->head->data.ptr_value)->val.str;
 	} else {
 		throw ParserException("TransformFuncCall - Expected 1, 2 or 3 qualifications");
 	}
 
 	//  transform children
 	vector<unique_ptr<ParsedExpression>> children;
-	if (root->args) {
-		TransformExpressionList(*root->args, children);
+	if (root.args) {
+		TransformExpressionList(*root.args, children);
 	}
-	if (children.size() == 1 && ExpressionIsEmptyStar(*children[0]) && !root->agg_distinct && !root->agg_order) {
+	if (children.size() == 1 && ExpressionIsEmptyStar(*children[0]) && !root.agg_distinct && !root.agg_order) {
 		// COUNT(*) gets translated into COUNT()
 		children.clear();
 	}
 
 	auto lowercase_name = StringUtil::Lower(function_name);
-	if (root->over) {
+	if (root.over) {
 		if (InWindowDefinition()) {
 			throw ParserException("window functions are not allowed in window definitions");
 		}
@@ -141,30 +135,30 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 			throw InternalException("Unknown/unsupported window function");
 		}
 
-		if (root->agg_distinct) {
+		if (root.agg_distinct) {
 			throw ParserException("DISTINCT is not implemented for window functions!");
 		}
 
-		if (root->agg_order) {
+		if (root.agg_order) {
 			throw ParserException("ORDER BY is not implemented for window functions!");
 		}
 
-		if (win_fun_type != ExpressionType::WINDOW_AGGREGATE && root->agg_filter) {
+		if (win_fun_type != ExpressionType::WINDOW_AGGREGATE && root.agg_filter) {
 			throw ParserException("FILTER is not implemented for non-aggregate window functions!");
 		}
-		if (root->export_state) {
+		if (root.export_state) {
 			throw ParserException("EXPORT_STATE is not supported for window functions!");
 		}
 
-		if (win_fun_type == ExpressionType::WINDOW_AGGREGATE && root->agg_ignore_nulls) {
+		if (win_fun_type == ExpressionType::WINDOW_AGGREGATE && root.agg_ignore_nulls) {
 			throw ParserException("IGNORE NULLS is not supported for windowed aggregates");
 		}
 
 		auto expr = make_uniq<WindowExpression>(win_fun_type, std::move(catalog), std::move(schema), lowercase_name);
-		expr->ignore_nulls = root->agg_ignore_nulls;
+		expr->ignore_nulls = root.agg_ignore_nulls;
 
-		if (root->agg_filter) {
-			auto filter_expr = TransformExpression(root->agg_filter);
+		if (root.agg_filter) {
+			auto filter_expr = TransformExpression(root.agg_filter);
 			expr->filter_expr = std::move(filter_expr);
 		}
 
@@ -197,7 +191,7 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 				}
 			}
 		}
-		auto window_spec = reinterpret_cast<duckdb_libpgquery::PGWindowDef *>(root->over);
+		auto window_spec = PGPointerCast<duckdb_libpgquery::PGWindowDef>(root.over);
 		if (window_spec->name) {
 			auto it = window_clauses.find(StringUtil::Lower(string(window_spec->name)));
 			if (it == window_clauses.end()) {
@@ -217,30 +211,30 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 			D_ASSERT(window_ref);
 		}
 		in_window_definition = true;
-		TransformWindowDef(window_ref, expr.get());
+		TransformWindowDef(*window_ref, *expr);
 		if (window_ref != window_spec) {
-			TransformWindowDef(window_spec, expr.get(), window_name);
+			TransformWindowDef(*window_spec, *expr, window_name);
 		}
-		TransformWindowFrame(window_spec, expr.get());
+		TransformWindowFrame(*window_spec, *expr);
 		in_window_definition = false;
-		expr->query_location = root->location;
+		expr->query_location = root.location;
 		return std::move(expr);
 	}
 
-	if (root->agg_ignore_nulls) {
+	if (root.agg_ignore_nulls) {
 		throw ParserException("IGNORE NULLS is not supported for non-window functions");
 	}
 
 	unique_ptr<ParsedExpression> filter_expr;
-	if (root->agg_filter) {
-		filter_expr = TransformExpression(root->agg_filter);
+	if (root.agg_filter) {
+		filter_expr = TransformExpression(root.agg_filter);
 	}
 
 	auto order_bys = make_uniq<OrderModifier>();
-	TransformOrderBy(root->agg_order, order_bys->orders);
+	TransformOrderBy(root.agg_order, order_bys->orders);
 
 	// Ordered aggregates can be either WITHIN GROUP or after the function arguments
-	if (root->agg_within_group) {
+	if (root.agg_within_group) {
 		//	https://www.postgresql.org/docs/current/functions-aggregate.html#FUNCTIONS-ORDEREDSET-TABLE
 		//  Since we implement "ordered aggregates" without sorting,
 		//  we map all the ones we support to the corresponding aggregate function.
@@ -304,17 +298,18 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 		}
 		auto arg_expr = children[0].get();
 		auto &order_by = order_bys->orders[0];
-		if (arg_expr->Equals(order_by.expression.get())) {
+		if (arg_expr->Equals(*order_by.expression)) {
 			auto sense = make_uniq<ConstantExpression>(EnumUtil::ToChars(order_by.type));
 			auto nulls = make_uniq<ConstantExpression>(EnumUtil::ToChars(order_by.null_order));
 			order_bys = nullptr;
 			auto unordered = make_uniq<FunctionExpression>(catalog, schema, lowercase_name.c_str(), std::move(children),
 			                                               std::move(filter_expr), std::move(order_bys),
-			                                               root->agg_distinct, false, root->export_state);
+			                                               root.agg_distinct, false, root.export_state);
 			lowercase_name = "list_sort";
 			order_bys.reset();   // NOLINT
 			filter_expr.reset(); // NOLINT
 			children.clear();    // NOLINT
+			root.agg_distinct = false;
 			children.emplace_back(std::move(unordered));
 			children.emplace_back(std::move(sense));
 			children.emplace_back(std::move(nulls));
@@ -323,13 +318,13 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 
 	auto function = make_uniq<FunctionExpression>(std::move(catalog), std::move(schema), lowercase_name.c_str(),
 	                                              std::move(children), std::move(filter_expr), std::move(order_bys),
-	                                              root->agg_distinct, false, root->export_state);
-	function->query_location = root->location;
+	                                              root.agg_distinct, false, root.export_state);
+	function->query_location = root.location;
 
 	return std::move(function);
 }
 
-unique_ptr<ParsedExpression> Transformer::TransformSQLValueFunction(duckdb_libpgquery::PGSQLValueFunction *node) {
+unique_ptr<ParsedExpression> Transformer::TransformSQLValueFunction(duckdb_libpgquery::PGSQLValueFunction &node) {
 	throw InternalException("SQL value functions should not be emitted by the parser");
 }
 

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

@@ -3,13 +3,13 @@
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformGroupingFunction(duckdb_libpgquery::PGGroupingFunc *n) {
+unique_ptr<ParsedExpression> Transformer::TransformGroupingFunction(duckdb_libpgquery::PGGroupingFunc &grouping) {
 	auto op = make_uniq<OperatorExpression>(ExpressionType::GROUPING_FUNCTION);
-	for (auto node = n->args->head; node; node = node->next) {
-		auto n = (duckdb_libpgquery::PGNode *)node->data.ptr_value;
+	for (auto node = grouping.args->head; node; node = node->next) {
+		auto n = PGPointerCast<duckdb_libpgquery::PGNode>(node->data.ptr_value);
 		op->children.push_back(TransformExpression(n));
 	}
-	op->query_location = n->location;
+	op->query_location = grouping.location;
 	return std::move(op);
 }
 

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

@@ -6,7 +6,7 @@
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformInterval(duckdb_libpgquery::PGIntervalConstant *node) {
+unique_ptr<ParsedExpression> Transformer::TransformInterval(duckdb_libpgquery::PGIntervalConstant &node) {
 	// handle post-fix notation of INTERVAL
 
 	// three scenarios
@@ -14,25 +14,25 @@ unique_ptr<ParsedExpression> Transformer::TransformInterval(duckdb_libpgquery::P
 	// interval 'string' year
 	// interval int year
 	unique_ptr<ParsedExpression> expr;
-	switch (node->val_type) {
+	switch (node.val_type) {
 	case duckdb_libpgquery::T_PGAExpr:
-		expr = TransformExpression(node->eval);
+		expr = TransformExpression(node.eval);
 		break;
 	case duckdb_libpgquery::T_PGString:
-		expr = make_uniq<ConstantExpression>(Value(node->sval));
+		expr = make_uniq<ConstantExpression>(Value(node.sval));
 		break;
 	case duckdb_libpgquery::T_PGInteger:
-		expr = make_uniq<ConstantExpression>(Value(node->ival));
+		expr = make_uniq<ConstantExpression>(Value(node.ival));
 		break;
 	default:
 		throw InternalException("Unsupported interval transformation");
 	}
 
-	if (!node->typmods) {
+	if (!node.typmods) {
 		return make_uniq<CastExpression>(LogicalType::INTERVAL, std::move(expr));
 	}
 
-	int32_t mask = ((duckdb_libpgquery::PGAConst *)node->typmods->head->data.ptr_value)->val.val.ival;
+	int32_t mask = PGPointerCast<duckdb_libpgquery::PGAConst>(node.typmods->head->data.ptr_value)->val.val.ival;
 	// these seemingly random constants are from datetime.hpp
 	// they are copied here to avoid having to include this header
 	// the bitshift is from the function INTERVAL_MASK in the parser

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

@@ -4,13 +4,12 @@
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformNullTest(duckdb_libpgquery::PGNullTest *root) {
-	D_ASSERT(root);
-	auto arg = TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(root->arg));
-	if (root->argisrow) {
+unique_ptr<ParsedExpression> Transformer::TransformNullTest(duckdb_libpgquery::PGNullTest &root) {
+	auto arg = TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(root.arg));
+	if (root.argisrow) {
 		throw NotImplementedException("IS NULL argisrow");
 	}
-	ExpressionType expr_type = (root->nulltesttype == duckdb_libpgquery::PG_IS_NULL)
+	ExpressionType expr_type = (root.nulltesttype == duckdb_libpgquery::PG_IS_NULL)
 	                               ? ExpressionType::OPERATOR_IS_NULL
 	                               : ExpressionType::OPERATOR_IS_NOT_NULL;
 

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

@@ -4,13 +4,12 @@
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformLambda(duckdb_libpgquery::PGLambdaFunction *node) {
+unique_ptr<ParsedExpression> Transformer::TransformLambda(duckdb_libpgquery::PGLambdaFunction &node) {
+	D_ASSERT(node.lhs);
+	D_ASSERT(node.rhs);
 
-	D_ASSERT(node->lhs);
-	D_ASSERT(node->rhs);
-
-	auto lhs = TransformExpression(node->lhs);
-	auto rhs = TransformExpression(node->rhs);
+	auto lhs = TransformExpression(node.lhs);
+	auto rhs = TransformExpression(node.rhs);
 	D_ASSERT(lhs);
 	D_ASSERT(rhs);
 	return make_uniq<LambdaExpression>(std::move(lhs), std::move(rhs));

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

@@ -57,17 +57,16 @@ unique_ptr<ParsedExpression> Transformer::TransformBinaryOperator(string op, uni
 	}
 }
 
-unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgquery::PGAExpr *root) {
-	D_ASSERT(root);
-	auto name = string((reinterpret_cast<duckdb_libpgquery::PGValue *>(root->name->head->data.ptr_value))->val.str);
+unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgquery::PGAExpr &root) {
+	auto name = string(PGPointerCast<duckdb_libpgquery::PGValue>(root.name->head->data.ptr_value)->val.str);
 
-	switch (root->kind) {
+	switch (root.kind) {
 	case duckdb_libpgquery::PG_AEXPR_OP_ALL:
 	case duckdb_libpgquery::PG_AEXPR_OP_ANY: {
 		// left=ANY(right)
 		// we turn this into left=ANY((SELECT UNNEST(right)))
-		auto left_expr = TransformExpression(root->lexpr);
-		auto right_expr = TransformExpression(root->rexpr);
+		auto left_expr = TransformExpression(root.lexpr);
+		auto right_expr = TransformExpression(root.rexpr);
 
 		auto subquery_expr = make_uniq<SubqueryExpression>();
 		auto select_statement = make_uniq<SelectStatement>();
@@ -82,9 +81,12 @@ unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgque
 		subquery_expr->subquery_type = SubqueryType::ANY;
 		subquery_expr->child = std::move(left_expr);
 		subquery_expr->comparison_type = OperatorToExpressionType(name);
-		subquery_expr->query_location = root->location;
+		subquery_expr->query_location = root.location;
+		if (subquery_expr->comparison_type == ExpressionType::INVALID) {
+			throw ParserException("Unsupported comparison \"%s\" for ANY/ALL subquery", name);
+		}
 
-		if (root->kind == duckdb_libpgquery::PG_AEXPR_OP_ALL) {
+		if (root.kind == duckdb_libpgquery::PG_AEXPR_OP_ALL) {
 			// ALL sublink is equivalent to NOT(ANY) with inverted comparison
 			// e.g. [= ALL()] is equivalent to [NOT(<> ANY())]
 			// first invert the comparison type
@@ -94,7 +96,7 @@ unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgque
 		return std::move(subquery_expr);
 	}
 	case duckdb_libpgquery::PG_AEXPR_IN: {
-		auto left_expr = TransformExpression(root->lexpr);
+		auto left_expr = TransformExpression(root.lexpr);
 		ExpressionType operator_type;
 		// this looks very odd, but seems to be the way to find out its NOT IN
 		if (name == "<>") {
@@ -105,35 +107,35 @@ unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgque
 			operator_type = ExpressionType::COMPARE_IN;
 		}
 		auto result = make_uniq<OperatorExpression>(operator_type, std::move(left_expr));
-		result->query_location = root->location;
-		TransformExpressionList(*((duckdb_libpgquery::PGList *)root->rexpr), result->children);
+		result->query_location = root.location;
+		TransformExpressionList(*PGPointerCast<duckdb_libpgquery::PGList>(root.rexpr), result->children);
 		return std::move(result);
 	}
 	// rewrite NULLIF(a, b) into CASE WHEN a=b THEN NULL ELSE a END
 	case duckdb_libpgquery::PG_AEXPR_NULLIF: {
 		vector<unique_ptr<ParsedExpression>> children;
-		children.push_back(TransformExpression(root->lexpr));
-		children.push_back(TransformExpression(root->rexpr));
+		children.push_back(TransformExpression(root.lexpr));
+		children.push_back(TransformExpression(root.rexpr));
 		return make_uniq<FunctionExpression>("nullif", std::move(children));
 	}
 	// rewrite (NOT) X BETWEEN A AND B into (NOT) AND(GREATERTHANOREQUALTO(X,
 	// A), LESSTHANOREQUALTO(X, B))
 	case duckdb_libpgquery::PG_AEXPR_BETWEEN:
 	case duckdb_libpgquery::PG_AEXPR_NOT_BETWEEN: {
-		auto between_args = reinterpret_cast<duckdb_libpgquery::PGList *>(root->rexpr);
+		auto between_args = PGPointerCast<duckdb_libpgquery::PGList>(root.rexpr);
 		if (between_args->length != 2 || !between_args->head->data.ptr_value || !between_args->tail->data.ptr_value) {
 			throw InternalException("(NOT) BETWEEN needs two args");
 		}
 
-		auto input = TransformExpression(root->lexpr);
+		auto input = TransformExpression(root.lexpr);
 		auto between_left =
-		    TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(between_args->head->data.ptr_value));
+		    TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(between_args->head->data.ptr_value));
 		auto between_right =
-		    TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(between_args->tail->data.ptr_value));
+		    TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(between_args->tail->data.ptr_value));
 
 		auto compare_between =
 		    make_uniq<BetweenExpression>(std::move(input), std::move(between_left), std::move(between_right));
-		if (root->kind == duckdb_libpgquery::PG_AEXPR_BETWEEN) {
+		if (root.kind == duckdb_libpgquery::PG_AEXPR_BETWEEN) {
 			return std::move(compare_between);
 		} else {
 			return make_uniq<OperatorExpression>(ExpressionType::OPERATOR_NOT, std::move(compare_between));
@@ -141,13 +143,13 @@ unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgque
 	}
 	// rewrite SIMILAR TO into regexp_full_match('asdf', '.*sd.*')
 	case duckdb_libpgquery::PG_AEXPR_SIMILAR: {
-		auto left_expr = TransformExpression(root->lexpr);
-		auto right_expr = TransformExpression(root->rexpr);
+		auto left_expr = TransformExpression(root.lexpr);
+		auto right_expr = TransformExpression(root.rexpr);
 
 		vector<unique_ptr<ParsedExpression>> children;
 		children.push_back(std::move(left_expr));
 
-		auto &similar_func = reinterpret_cast<FunctionExpression &>(*right_expr);
+		auto &similar_func = right_expr->Cast<FunctionExpression>();
 		D_ASSERT(similar_func.function_name == "similar_escape");
 		D_ASSERT(similar_func.children.size() == 2);
 		if (similar_func.children[1]->type != ExpressionType::VALUE_CONSTANT) {
@@ -176,14 +178,14 @@ unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgque
 		}
 	}
 	case duckdb_libpgquery::PG_AEXPR_NOT_DISTINCT: {
-		auto left_expr = TransformExpression(root->lexpr);
-		auto right_expr = TransformExpression(root->rexpr);
+		auto left_expr = TransformExpression(root.lexpr);
+		auto right_expr = TransformExpression(root.rexpr);
 		return make_uniq<ComparisonExpression>(ExpressionType::COMPARE_NOT_DISTINCT_FROM, std::move(left_expr),
 		                                       std::move(right_expr));
 	}
 	case duckdb_libpgquery::PG_AEXPR_DISTINCT: {
-		auto left_expr = TransformExpression(root->lexpr);
-		auto right_expr = TransformExpression(root->rexpr);
+		auto left_expr = TransformExpression(root.lexpr);
+		auto right_expr = TransformExpression(root.rexpr);
 		return make_uniq<ComparisonExpression>(ExpressionType::COMPARE_DISTINCT_FROM, std::move(left_expr),
 		                                       std::move(right_expr));
 	}
@@ -191,8 +193,8 @@ unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgque
 	default:
 		break;
 	}
-	auto left_expr = TransformExpression(root->lexpr);
-	auto right_expr = TransformExpression(root->rexpr);
+	auto left_expr = TransformExpression(root.lexpr);
+	auto right_expr = TransformExpression(root.rexpr);
 
 	if (!left_expr) {
 		// prefix operator
@@ -205,10 +207,10 @@ unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgque
 	}
 }
 
-unique_ptr<ParsedExpression> Transformer::TransformAExpr(duckdb_libpgquery::PGAExpr *root) {
+unique_ptr<ParsedExpression> Transformer::TransformAExpr(duckdb_libpgquery::PGAExpr &root) {
 	auto result = TransformAExprInternal(root);
 	if (result) {
-		result->query_location = root->location;
+		result->query_location = root.location;
 	}
 	return result;
 }

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

@@ -4,39 +4,38 @@
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformParamRef(duckdb_libpgquery::PGParamRef *node) {
-	D_ASSERT(node);
+unique_ptr<ParsedExpression> Transformer::TransformParamRef(duckdb_libpgquery::PGParamRef &node) {
 	auto expr = make_uniq<ParameterExpression>();
-	if (node->number < 0) {
+	if (node.number < 0) {
 		throw ParserException("Parameter numbers cannot be negative");
 	}
 
-	if (node->name) {
+	if (node.name) {
 		// This is a named parameter, try to find an entry for it
-		D_ASSERT(node->number == 0);
+		D_ASSERT(node.number == 0);
 		int32_t index;
-		if (GetNamedParam(node->name, index)) {
+		if (GetNamedParam(node.name, index)) {
 			// We've seen this named parameter before and assigned it an index!
-			node->number = index;
+			node.number = index;
 		}
 	}
-	if (node->number == 0) {
+	if (node.number == 0) {
 		expr->parameter_nr = ParamCount() + 1;
-		if (node->name && !HasNamedParameters() && ParamCount() != 0) {
+		if (node.name && !HasNamedParameters() && ParamCount() != 0) {
 			// This parameter is named, but there were other parameter before it, and they were not named
 			throw NotImplementedException("Mixing positional and named parameters is not supported yet");
 		}
-		if (node->name) {
-			D_ASSERT(!named_param_map.count(node->name));
+		if (node.name) {
+			D_ASSERT(!named_param_map.count(node.name));
 			// Add it to the named parameter map so we can find it next time it's referenced
-			SetNamedParam(node->name, expr->parameter_nr);
+			SetNamedParam(node.name, expr->parameter_nr);
 		}
 	} else {
-		if (!node->name && HasNamedParameters()) {
+		if (!node.name && HasNamedParameters()) {
 			// This parameter does not have a name, but the named param map is not empty
 			throw NotImplementedException("Mixing positional and named parameters is not supported yet");
 		}
-		expr->parameter_nr = node->number;
+		expr->parameter_nr = node.number;
 	}
 	SetParamCount(MaxValue<idx_t>(ParamCount(), expr->parameter_nr));
 	return std::move(expr);

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

@@ -4,12 +4,12 @@
 
 namespace duckdb {
 
-unique_ptr<ParsedExpression> Transformer::TransformPositionalReference(duckdb_libpgquery::PGPositionalReference *node) {
-	if (node->position <= 0) {
+unique_ptr<ParsedExpression> Transformer::TransformPositionalReference(duckdb_libpgquery::PGPositionalReference &node) {
+	if (node.position <= 0) {
 		throw ParserException("Positional reference node needs to be >= 1");
 	}
-	auto result = make_uniq<PositionalReferenceExpression>(node->position);
-	result->query_location = node->location;
+	auto result = make_uniq<PositionalReferenceExpression>(node.position);
+	result->query_location = node.location;
 	return std::move(result);
 }