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

package/src/duckdb/src/parser/parsed_expression.cpp

@@ -7,6 +7,7 @@
 #include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/common/serializer/format_serializer.hpp"
 #include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/parser/expression_util.hpp"
 
 namespace duckdb {
 
@@ -48,46 +49,46 @@ bool ParsedExpression::HasSubquery() const {
 	return has_subquery;
 }
 
-bool ParsedExpression::Equals(const BaseExpression *other) const {
+bool ParsedExpression::Equals(const BaseExpression &other) const {
 	if (!BaseExpression::Equals(other)) {
 		return false;
 	}
 	switch (expression_class) {
 	case ExpressionClass::BETWEEN:
-		return BetweenExpression::Equal((BetweenExpression *)this, (BetweenExpression *)other);
+		return BetweenExpression::Equal(Cast<BetweenExpression>(), other.Cast<BetweenExpression>());
 	case ExpressionClass::CASE:
-		return CaseExpression::Equal((CaseExpression *)this, (CaseExpression *)other);
+		return CaseExpression::Equal(Cast<CaseExpression>(), other.Cast<CaseExpression>());
 	case ExpressionClass::CAST:
-		return CastExpression::Equal((CastExpression *)this, (CastExpression *)other);
+		return CastExpression::Equal(Cast<CastExpression>(), other.Cast<CastExpression>());
 	case ExpressionClass::COLLATE:
-		return CollateExpression::Equal((CollateExpression *)this, (CollateExpression *)other);
+		return CollateExpression::Equal(Cast<CollateExpression>(), other.Cast<CollateExpression>());
 	case ExpressionClass::COLUMN_REF:
-		return ColumnRefExpression::Equal((ColumnRefExpression *)this, (ColumnRefExpression *)other);
+		return ColumnRefExpression::Equal(Cast<ColumnRefExpression>(), other.Cast<ColumnRefExpression>());
 	case ExpressionClass::COMPARISON:
-		return ComparisonExpression::Equal((ComparisonExpression *)this, (ComparisonExpression *)other);
+		return ComparisonExpression::Equal(Cast<ComparisonExpression>(), other.Cast<ComparisonExpression>());
 	case ExpressionClass::CONJUNCTION:
-		return ConjunctionExpression::Equal((ConjunctionExpression *)this, (ConjunctionExpression *)other);
+		return ConjunctionExpression::Equal(Cast<ConjunctionExpression>(), other.Cast<ConjunctionExpression>());
 	case ExpressionClass::CONSTANT:
-		return ConstantExpression::Equal((ConstantExpression *)this, (ConstantExpression *)other);
+		return ConstantExpression::Equal(Cast<ConstantExpression>(), other.Cast<ConstantExpression>());
 	case ExpressionClass::DEFAULT:
 		return true;
 	case ExpressionClass::FUNCTION:
-		return FunctionExpression::Equal((FunctionExpression *)this, (FunctionExpression *)other);
+		return FunctionExpression::Equal(Cast<FunctionExpression>(), other.Cast<FunctionExpression>());
 	case ExpressionClass::LAMBDA:
-		return LambdaExpression::Equal((LambdaExpression *)this, (LambdaExpression *)other);
+		return LambdaExpression::Equal(Cast<LambdaExpression>(), other.Cast<LambdaExpression>());
 	case ExpressionClass::OPERATOR:
-		return OperatorExpression::Equal((OperatorExpression *)this, (OperatorExpression *)other);
+		return OperatorExpression::Equal(Cast<OperatorExpression>(), other.Cast<OperatorExpression>());
 	case ExpressionClass::PARAMETER:
-		return ParameterExpression::Equal((ParameterExpression *)this, (ParameterExpression *)other);
+		return ParameterExpression::Equal(Cast<ParameterExpression>(), other.Cast<ParameterExpression>());
 	case ExpressionClass::POSITIONAL_REFERENCE:
-		return PositionalReferenceExpression::Equal((PositionalReferenceExpression *)this,
-		                                            (PositionalReferenceExpression *)other);
+		return PositionalReferenceExpression::Equal(Cast<PositionalReferenceExpression>(),
+		                                            other.Cast<PositionalReferenceExpression>());
 	case ExpressionClass::STAR:
-		return StarExpression::Equal((StarExpression *)this, (StarExpression *)other);
+		return StarExpression::Equal(Cast<StarExpression>(), other.Cast<StarExpression>());
 	case ExpressionClass::SUBQUERY:
-		return SubqueryExpression::Equal((SubqueryExpression *)this, (SubqueryExpression *)other);
+		return SubqueryExpression::Equal(Cast<SubqueryExpression>(), other.Cast<SubqueryExpression>());
 	case ExpressionClass::WINDOW:
-		return WindowExpression::Equal((WindowExpression *)this, (WindowExpression *)other);
+		return WindowExpression::Equal(Cast<WindowExpression>(), other.Cast<WindowExpression>());
 	default:
 		throw SerializationException("Unsupported type for expression comparison!");
 	}
@@ -246,4 +247,19 @@ unique_ptr<ParsedExpression> ParsedExpression::Deserialize(Deserializer &source)
 	return result;
 }
 
+bool ParsedExpression::Equals(const unique_ptr<ParsedExpression> &left, const unique_ptr<ParsedExpression> &right) {
+	if (left.get() == right.get()) {
+		return true;
+	}
+	if (!left || !right) {
+		return false;
+	}
+	return left->Equals(*right);
+}
+
+bool ParsedExpression::ListEquals(const vector<unique_ptr<ParsedExpression>> &left,
+                                  const vector<unique_ptr<ParsedExpression>> &right) {
+	return ExpressionUtil::ListEquals(left, right);
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_expression_iterator.cpp

@@ -158,7 +158,7 @@ void ParsedExpressionIterator::EnumerateQueryNodeModifiers(
 	for (auto &modifier : node.modifiers) {
 		switch (modifier->type) {
 		case ResultModifierType::LIMIT_MODIFIER: {
-			auto &limit_modifier = (LimitModifier &)*modifier;
+			auto &limit_modifier = modifier->Cast<LimitModifier>();
 			if (limit_modifier.limit) {
 				callback(limit_modifier.limit);
 			}
@@ -168,7 +168,7 @@ void ParsedExpressionIterator::EnumerateQueryNodeModifiers(
 		} break;
 
 		case ResultModifierType::LIMIT_PERCENT_MODIFIER: {
-			auto &limit_modifier = (LimitPercentModifier &)*modifier;
+			auto &limit_modifier = modifier->Cast<LimitPercentModifier>();
 			if (limit_modifier.limit) {
 				callback(limit_modifier.limit);
 			}
@@ -178,14 +178,14 @@ void ParsedExpressionIterator::EnumerateQueryNodeModifiers(
 		} break;
 
 		case ResultModifierType::ORDER_MODIFIER: {
-			auto &order_modifier = (OrderModifier &)*modifier;
+			auto &order_modifier = modifier->Cast<OrderModifier>();
 			for (auto &order : order_modifier.orders) {
 				callback(order.expression);
 			}
 		} break;
 
 		case ResultModifierType::DISTINCT_MODIFIER: {
-			auto &distinct_modifier = (DistinctModifier &)*modifier;
+			auto &distinct_modifier = modifier->Cast<DistinctModifier>();
 			for (auto &target : distinct_modifier.distinct_on_targets) {
 				callback(target);
 			}

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

@@ -51,7 +51,7 @@ static bool StripUnicodeSpaces(const string &query_str, string &new_query) {
 	idx_t pos = 0;
 	unsigned char quote;
 	vector<UnicodeSpace> unicode_spaces;
-	auto query = (unsigned char *)query_str.c_str();
+	auto query = const_uchar_ptr_cast(query_str.c_str());
 	auto qsize = query_str.size();
 
 regular:
@@ -288,7 +288,7 @@ vector<OrderByNode> Parser::ParseOrderList(const string &select_list, ParserOpti
 	    select_node.modifiers.size() != 1) {
 		throw ParserException("Expected a single ORDER clause");
 	}
-	auto &order = (OrderModifier &)*select_node.modifiers[0];
+	auto &order = select_node.modifiers[0]->Cast<OrderModifier>();
 	return std::move(order.orders);
 }
 
@@ -341,7 +341,7 @@ ColumnList Parser::ParseColumnList(const string &column_list, ParserOptions opti
 	if (create.info->type != CatalogType::TABLE_ENTRY) {
 		throw InternalException("Expected a single CREATE TABLE statement");
 	}
-	auto &info = ((CreateTableInfo &)*create.info);
+	auto &info = create.info->Cast<CreateTableInfo>();
 	return std::move(info.columns);
 }
 

package/src/duckdb/src/parser/query_node/select_node.cpp

@@ -19,7 +19,7 @@ string SelectNode::ToString() const {
 	// search for a distinct modifier
 	for (idx_t modifier_idx = 0; modifier_idx < modifiers.size(); modifier_idx++) {
 		if (modifiers[modifier_idx]->type == ResultModifierType::DISTINCT_MODIFIER) {
-			auto &distinct_modifier = (DistinctModifier &)*modifiers[modifier_idx];
+			auto &distinct_modifier = modifiers[modifier_idx]->Cast<DistinctModifier>();
 			result += "DISTINCT ";
 			if (!distinct_modifier.distinct_on_targets.empty()) {
 				result += "ON (";
@@ -120,22 +120,15 @@ bool SelectNode::Equals(const QueryNode *other_p) const {
 		return false;
 	}
 	// FROM
-	if (from_table) {
-		// we have a FROM clause, compare to the other one
-		if (!from_table->Equals(other.from_table.get())) {
-			return false;
-		}
-	} else if (other.from_table) {
-		// we don't have a FROM clause, if the other statement has one they are
-		// not equal
+	if (!TableRef::Equals(from_table, other.from_table)) {
 		return false;
 	}
 	// WHERE
-	if (!BaseExpression::Equals(where_clause.get(), other.where_clause.get())) {
+	if (!ParsedExpression::Equals(where_clause, other.where_clause)) {
 		return false;
 	}
 	// GROUP BY
-	if (!ExpressionUtil::ListEquals(groups.group_expressions, other.groups.group_expressions)) {
+	if (!ParsedExpression::ListEquals(groups.group_expressions, other.groups.group_expressions)) {
 		return false;
 	}
 	if (groups.grouping_sets != other.groups.grouping_sets) {
@@ -145,11 +138,11 @@ bool SelectNode::Equals(const QueryNode *other_p) const {
 		return false;
 	}
 	// HAVING
-	if (!BaseExpression::Equals(having.get(), other.having.get())) {
+	if (!ParsedExpression::Equals(having, other.having)) {
 		return false;
 	}
 	// QUALIFY
-	if (!BaseExpression::Equals(qualify.get(), other.qualify.get())) {
+	if (!ParsedExpression::Equals(qualify, other.qualify)) {
 		return false;
 	}
 	return true;

package/src/duckdb/src/parser/query_node.cpp

@@ -82,7 +82,7 @@ string QueryNode::ResultModifiersToString() const {
 	for (idx_t modifier_idx = 0; modifier_idx < modifiers.size(); modifier_idx++) {
 		auto &modifier = *modifiers[modifier_idx];
 		if (modifier.type == ResultModifierType::ORDER_MODIFIER) {
-			auto &order_modifier = (OrderModifier &)modifier;
+			auto &order_modifier = modifier.Cast<OrderModifier>();
 			result += " ORDER BY ";
 			for (idx_t k = 0; k < order_modifier.orders.size(); k++) {
 				if (k > 0) {
@@ -91,7 +91,7 @@ string QueryNode::ResultModifiersToString() const {
 				result += order_modifier.orders[k].ToString();
 			}
 		} else if (modifier.type == ResultModifierType::LIMIT_MODIFIER) {
-			auto &limit_modifier = (LimitModifier &)modifier;
+			auto &limit_modifier = modifier.Cast<LimitModifier>();
 			if (limit_modifier.limit) {
 				result += " LIMIT " + limit_modifier.limit->ToString();
 			}
@@ -99,7 +99,7 @@ string QueryNode::ResultModifiersToString() const {
 				result += " OFFSET " + limit_modifier.offset->ToString();
 			}
 		} else if (modifier.type == ResultModifierType::LIMIT_PERCENT_MODIFIER) {
-			auto &limit_p_modifier = (LimitPercentModifier &)modifier;
+			auto &limit_p_modifier = modifier.Cast<LimitPercentModifier>();
 			if (limit_p_modifier.limit) {
 				result += " LIMIT (" + limit_p_modifier.limit->ToString() + ") %";
 			}
@@ -121,11 +121,12 @@ bool QueryNode::Equals(const QueryNode *other) const {
 	if (other->type != this->type) {
 		return false;
 	}
+
 	if (modifiers.size() != other->modifiers.size()) {
 		return false;
 	}
 	for (idx_t i = 0; i < modifiers.size(); i++) {
-		if (!modifiers[i]->Equals(other->modifiers[i].get())) {
+		if (!modifiers[i]->Equals(*other->modifiers[i])) {
 			return false;
 		}
 	}
@@ -141,7 +142,7 @@ bool QueryNode::Equals(const QueryNode *other) const {
 		if (entry.second->aliases != other_entry->second->aliases) {
 			return false;
 		}
-		if (!entry.second->query->Equals(other_entry->second->query.get())) {
+		if (!entry.second->query->Equals(*other_entry->second->query)) {
 			return false;
 		}
 	}
@@ -257,7 +258,7 @@ void QueryNode::AddDistinct() {
 	for (idx_t modifier_idx = modifiers.size(); modifier_idx > 0; modifier_idx--) {
 		auto &modifier = *modifiers[modifier_idx - 1];
 		if (modifier.type == ResultModifierType::DISTINCT_MODIFIER) {
-			auto &distinct_modifier = (DistinctModifier &)modifier;
+			auto &distinct_modifier = modifier.Cast<DistinctModifier>();
 			if (distinct_modifier.distinct_on_targets.empty()) {
 				// we have a DISTINCT without an ON clause - this distinct does not need to be added
 				return;

package/src/duckdb/src/parser/result_modifier.cpp

@@ -6,11 +6,8 @@
 
 namespace duckdb {
 
-bool ResultModifier::Equals(const ResultModifier *other) const {
-	if (!other) {
-		return false;
-	}
-	return type == other->type;
+bool ResultModifier::Equals(const ResultModifier &other) const {
+	return type == other.type;
 }
 
 void ResultModifier::Serialize(Serializer &serializer) const {
@@ -72,15 +69,15 @@ unique_ptr<ResultModifier> ResultModifier::Deserialize(Deserializer &source) {
 	return result;
 }
 
-bool LimitModifier::Equals(const ResultModifier *other_p) const {
+bool LimitModifier::Equals(const ResultModifier &other_p) const {
 	if (!ResultModifier::Equals(other_p)) {
 		return false;
 	}
-	auto &other = (LimitModifier &)*other_p;
-	if (!BaseExpression::Equals(limit.get(), other.limit.get())) {
+	auto &other = other_p.Cast<LimitModifier>();
+	if (!ParsedExpression::Equals(limit, other.limit)) {
 		return false;
 	}
-	if (!BaseExpression::Equals(offset.get(), other.offset.get())) {
+	if (!ParsedExpression::Equals(offset, other.offset)) {
 		return false;
 	}
 	return true;
@@ -122,11 +119,11 @@ unique_ptr<ResultModifier> LimitModifier::Deserialize(FieldReader &reader) {
 	return std::move(mod);
 }
 
-bool DistinctModifier::Equals(const ResultModifier *other_p) const {
+bool DistinctModifier::Equals(const ResultModifier &other_p) const {
 	if (!ResultModifier::Equals(other_p)) {
 		return false;
 	}
-	auto &other = (DistinctModifier &)*other_p;
+	auto &other = other_p.Cast<DistinctModifier>();
 	if (!ExpressionUtil::ListEquals(distinct_on_targets, other.distinct_on_targets)) {
 		return false;
 	}
@@ -162,11 +159,11 @@ unique_ptr<ResultModifier> DistinctModifier::Deserialize(FieldReader &reader) {
 	return std::move(mod);
 }
 
-bool OrderModifier::Equals(const ResultModifier *other_p) const {
+bool OrderModifier::Equals(const ResultModifier &other_p) const {
 	if (!ResultModifier::Equals(other_p)) {
 		return false;
 	}
-	auto &other = (OrderModifier &)*other_p;
+	auto &other = other_p.Cast<OrderModifier>();
 	if (orders.size() != other.orders.size()) {
 		return false;
 	}
@@ -174,13 +171,23 @@ bool OrderModifier::Equals(const ResultModifier *other_p) const {
 		if (orders[i].type != other.orders[i].type) {
 			return false;
 		}
-		if (!BaseExpression::Equals(orders[i].expression.get(), other.orders[i].expression.get())) {
+		if (!BaseExpression::Equals(*orders[i].expression, *other.orders[i].expression)) {
 			return false;
 		}
 	}
 	return true;
 }
 
+bool OrderModifier::Equals(const unique_ptr<OrderModifier> &left, const unique_ptr<OrderModifier> &right) {
+	if (left.get() == right.get()) {
+		return true;
+	}
+	if (!left || !right) {
+		return false;
+	}
+	return left->Equals(*right);
+}
+
 unique_ptr<ResultModifier> OrderModifier::Copy() const {
 	auto copy = make_uniq<OrderModifier>();
 	for (auto &order : orders) {
@@ -265,15 +272,15 @@ unique_ptr<ResultModifier> OrderModifier::Deserialize(FieldReader &reader) {
 	return std::move(mod);
 }
 
-bool LimitPercentModifier::Equals(const ResultModifier *other_p) const {
+bool LimitPercentModifier::Equals(const ResultModifier &other_p) const {
 	if (!ResultModifier::Equals(other_p)) {
 		return false;
 	}
-	auto &other = (LimitPercentModifier &)*other_p;
-	if (!BaseExpression::Equals(limit.get(), other.limit.get())) {
+	auto &other = other_p.Cast<LimitPercentModifier>();
+	if (!ParsedExpression::Equals(limit, other.limit)) {
 		return false;
 	}
-	if (!BaseExpression::Equals(offset.get(), other.offset.get())) {
+	if (!ParsedExpression::Equals(offset, other.offset)) {
 		return false;
 	}
 	return true;

package/src/duckdb/src/parser/statement/select_statement.cpp

@@ -33,11 +33,11 @@ unique_ptr<SelectStatement> SelectStatement::FormatDeserialize(FormatDeserialize
 	return result;
 }
 
-bool SelectStatement::Equals(const SQLStatement *other_p) const {
-	if (type != other_p->type) {
+bool SelectStatement::Equals(const SQLStatement &other_p) const {
+	if (type != other_p.type) {
 		return false;
 	}
-	auto &other = other_p->Cast<SelectStatement>();
+	auto &other = other_p.Cast<SelectStatement>();
 	return node->Equals(other.node.get());
 }
 

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

@@ -15,13 +15,13 @@ string BaseTableRef::ToString() const {
 	return BaseToString(result, column_name_alias);
 }
 
-bool BaseTableRef::Equals(const TableRef *other_p) const {
+bool BaseTableRef::Equals(const TableRef &other_p) const {
 	if (!TableRef::Equals(other_p)) {
 		return false;
 	}
-	auto other = (BaseTableRef *)other_p;
-	return other->catalog_name == catalog_name && other->schema_name == schema_name &&
-	       other->table_name == table_name && column_name_alias == other->column_name_alias;
+	auto &other = other_p.Cast<BaseTableRef>();
+	return other.catalog_name == catalog_name && other.schema_name == schema_name && other.table_name == table_name &&
+	       column_name_alias == other.column_name_alias;
 }
 
 void BaseTableRef::Serialize(FieldWriter &writer) const {

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

@@ -8,7 +8,7 @@ string EmptyTableRef::ToString() const {
 	return "";
 }
 
-bool EmptyTableRef::Equals(const TableRef *other) const {
+bool EmptyTableRef::Equals(const TableRef &other) const {
 	return TableRef::Equals(other);
 }
 

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

@@ -27,20 +27,20 @@ string ExpressionListRef::ToString() const {
 	return BaseToString(result, expected_names);
 }
 
-bool ExpressionListRef::Equals(const TableRef *other_p) const {
+bool ExpressionListRef::Equals(const TableRef &other_p) const {
 	if (!TableRef::Equals(other_p)) {
 		return false;
 	}
-	auto other = (ExpressionListRef *)other_p;
-	if (values.size() != other->values.size()) {
+	auto &other = other_p.Cast<ExpressionListRef>();
+	if (values.size() != other.values.size()) {
 		return false;
 	}
 	for (idx_t i = 0; i < values.size(); i++) {
-		if (values[i].size() != other->values[i].size()) {
+		if (values[i].size() != other.values[i].size()) {
 			return false;
 		}
 		for (idx_t j = 0; j < values[i].size(); j++) {
-			if (!values[i][j]->Equals(other->values[i][j].get())) {
+			if (!values[i][j]->Equals(*other.values[i][j])) {
 				return false;
 			}
 		}

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

@@ -48,21 +48,21 @@ string JoinRef::ToString() const {
 	return result;
 }
 
-bool JoinRef::Equals(const TableRef *other_p) const {
+bool JoinRef::Equals(const TableRef &other_p) const {
 	if (!TableRef::Equals(other_p)) {
 		return false;
 	}
-	auto other = (JoinRef *)other_p;
-	if (using_columns.size() != other->using_columns.size()) {
+	auto &other = other_p.Cast<JoinRef>();
+	if (using_columns.size() != other.using_columns.size()) {
 		return false;
 	}
 	for (idx_t i = 0; i < using_columns.size(); i++) {
-		if (using_columns[i] != other->using_columns[i]) {
+		if (using_columns[i] != other.using_columns[i]) {
 			return false;
 		}
 	}
-	return left->Equals(other->left.get()) && right->Equals(other->right.get()) &&
-	       BaseExpression::Equals(condition.get(), other->condition.get()) && type == other->type;
+	return left->Equals(*other.left) && right->Equals(*other.right) &&
+	       ParsedExpression::Equals(condition, other.condition) && type == other.type;
 }
 
 unique_ptr<TableRef> JoinRef::Copy() {

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