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

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

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,13 +298,13 @@ 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
@@ -323,13 +317,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");
 }