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

package/src/duckdb/src/parser/expression/parameter_expression.cpp

@@ -25,8 +25,8 @@ unique_ptr<ParsedExpression> ParameterExpression::Copy() const {
 	return std::move(copy);
 }
 
-bool ParameterExpression::Equal(const ParameterExpression *a, const ParameterExpression *b) {
-	return a->parameter_nr == b->parameter_nr;
+bool ParameterExpression::Equal(const ParameterExpression &a, const ParameterExpression &b) {
+	return a.parameter_nr == b.parameter_nr;
 }
 
 hash_t ParameterExpression::Hash() const {

package/src/duckdb/src/parser/expression/positional_reference_expression.cpp

@@ -18,9 +18,9 @@ string PositionalReferenceExpression::ToString() const {
 	return "#" + to_string(index);
 }
 
-bool PositionalReferenceExpression::Equal(const PositionalReferenceExpression *a,
-                                          const PositionalReferenceExpression *b) {
-	return a->index == b->index;
+bool PositionalReferenceExpression::Equal(const PositionalReferenceExpression &a,
+                                          const PositionalReferenceExpression &b) {
+	return a.index == b.index;
 }
 
 unique_ptr<ParsedExpression> PositionalReferenceExpression::Copy() const {

package/src/duckdb/src/parser/expression/star_expression.cpp

@@ -54,26 +54,26 @@ string StarExpression::ToString() const {
 	return result;
 }
 
-bool StarExpression::Equal(const StarExpression *a, const StarExpression *b) {
-	if (a->relation_name != b->relation_name || a->exclude_list != b->exclude_list) {
+bool StarExpression::Equal(const StarExpression &a, const StarExpression &b) {
+	if (a.relation_name != b.relation_name || a.exclude_list != b.exclude_list) {
 		return false;
 	}
-	if (a->columns != b->columns) {
+	if (a.columns != b.columns) {
 		return false;
 	}
-	if (a->replace_list.size() != b->replace_list.size()) {
+	if (a.replace_list.size() != b.replace_list.size()) {
 		return false;
 	}
-	for (auto &entry : a->replace_list) {
-		auto other_entry = b->replace_list.find(entry.first);
-		if (other_entry == b->replace_list.end()) {
+	for (auto &entry : a.replace_list) {
+		auto other_entry = b.replace_list.find(entry.first);
+		if (other_entry == b.replace_list.end()) {
 			return false;
 		}
-		if (!entry.second->Equals(other_entry->second.get())) {
+		if (!entry.second->Equals(*other_entry->second)) {
 			return false;
 		}
 	}
-	if (!BaseExpression::Equals(a->expr.get(), b->expr.get())) {
+	if (!ParsedExpression::Equals(a.expr, b.expr)) {
 		return false;
 	}
 	return true;

package/src/duckdb/src/parser/expression/subquery_expression.cpp

@@ -28,15 +28,15 @@ string SubqueryExpression::ToString() const {
 	}
 }
 
-bool SubqueryExpression::Equal(const SubqueryExpression *a, const SubqueryExpression *b) {
-	if (!a->subquery || !b->subquery) {
+bool SubqueryExpression::Equal(const SubqueryExpression &a, const SubqueryExpression &b) {
+	if (!a.subquery || !b.subquery) {
 		return false;
 	}
-	if (!BaseExpression::Equals(a->child.get(), b->child.get())) {
+	if (!ParsedExpression::Equals(a.child, b.child)) {
 		return false;
 	}
-	return a->comparison_type == b->comparison_type && a->subquery_type == b->subquery_type &&
-	       a->subquery->Equals(b->subquery.get());
+	return a.comparison_type == b.comparison_type && a.subquery_type == b.subquery_type &&
+	       a.subquery->Equals(*b.subquery);
 }
 
 unique_ptr<ParsedExpression> SubqueryExpression::Copy() const {

package/src/duckdb/src/parser/expression/window_expression.cpp

@@ -63,53 +63,42 @@ string WindowExpression::ToString() const {
 	return ToString<WindowExpression, ParsedExpression, OrderByNode>(*this, schema, function_name);
 }
 
-bool WindowExpression::Equal(const WindowExpression *a, const WindowExpression *b) {
+bool WindowExpression::Equal(const WindowExpression &a, const WindowExpression &b) {
 	// check if the child expressions are equivalent
-	if (b->children.size() != a->children.size()) {
+	if (a.ignore_nulls != b.ignore_nulls) {
 		return false;
 	}
-	if (a->ignore_nulls != b->ignore_nulls) {
+	if (!ParsedExpression::ListEquals(a.children, b.children)) {
 		return false;
 	}
-	for (idx_t i = 0; i < a->children.size(); i++) {
-		if (!a->children[i]->Equals(b->children[i].get())) {
-			return false;
-		}
-	}
-	if (a->start != b->start || a->end != b->end) {
+	if (a.start != b.start || a.end != b.end) {
 		return false;
 	}
 	// check if the framing expressions are equivalentbind_
-	if (!BaseExpression::Equals(a->start_expr.get(), b->start_expr.get()) ||
-	    !BaseExpression::Equals(a->end_expr.get(), b->end_expr.get()) ||
-	    !BaseExpression::Equals(a->offset_expr.get(), b->offset_expr.get()) ||
-	    !BaseExpression::Equals(a->default_expr.get(), b->default_expr.get())) {
+	if (!ParsedExpression::Equals(a.start_expr, b.start_expr) || !ParsedExpression::Equals(a.end_expr, b.end_expr) ||
+	    !ParsedExpression::Equals(a.offset_expr, b.offset_expr) ||
+	    !ParsedExpression::Equals(a.default_expr, b.default_expr)) {
 		return false;
 	}
 
 	// check if the partitions are equivalent
-	if (a->partitions.size() != b->partitions.size()) {
+	if (!ParsedExpression::ListEquals(a.partitions, b.partitions)) {
 		return false;
 	}
-	for (idx_t i = 0; i < a->partitions.size(); i++) {
-		if (!a->partitions[i]->Equals(b->partitions[i].get())) {
-			return false;
-		}
-	}
 	// check if the orderings are equivalent
-	if (a->orders.size() != b->orders.size()) {
+	if (a.orders.size() != b.orders.size()) {
 		return false;
 	}
-	for (idx_t i = 0; i < a->orders.size(); i++) {
-		if (a->orders[i].type != b->orders[i].type) {
+	for (idx_t i = 0; i < a.orders.size(); i++) {
+		if (a.orders[i].type != b.orders[i].type) {
 			return false;
 		}
-		if (!a->orders[i].expression->Equals(b->orders[i].expression.get())) {
+		if (!a.orders[i].expression->Equals(*b.orders[i].expression)) {
 			return false;
 		}
 	}
 	// check if the filter clauses are equivalent
-	if (!BaseExpression::Equals(a->filter_expr.get(), b->filter_expr.get())) {
+	if (!ParsedExpression::Equals(a.filter_expr, b.filter_expr)) {
 		return false;
 	}
 

package/src/duckdb/src/parser/parsed_data/create_info.cpp

@@ -5,7 +5,6 @@
 #include "duckdb/parser/parsed_data/create_table_info.hpp"
 #include "duckdb/parser/parsed_data/create_view_info.hpp"
 #include "duckdb/parser/parsed_data/create_sequence_info.hpp"
-#include "duckdb/parser/parsed_data/create_database_info.hpp"
 #include "duckdb/parser/parsed_data/create_type_info.hpp"
 #include "duckdb/parser/parsed_data/alter_info.hpp"
 #include "duckdb/parser/parsed_data/create_macro_info.hpp"
@@ -43,8 +42,6 @@ unique_ptr<CreateInfo> CreateInfo::Deserialize(Deserializer &deserializer) {
 		return CreateSchemaInfo::Deserialize(deserializer);
 	case CatalogType::VIEW_ENTRY:
 		return CreateViewInfo::Deserialize(deserializer);
-	case CatalogType::DATABASE_ENTRY:
-		return CreateDatabaseInfo::Deserialize(deserializer);
 	case CatalogType::TYPE_ENTRY:
 		return CreateTypeInfo::Deserialize(deserializer);
 	case CatalogType::MACRO_ENTRY:

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

@@ -45,13 +45,13 @@ static bool ReplaceUnicodeSpaces(const string &query, string &new_query, vector<
 // This function strips unicode space characters from the query and replaces them with regular spaces
 // It returns true if any unicode space characters were found and stripped
 // See here for a list of unicode space characters - https://jkorpela.fi/chars/spaces.html
-static bool StripUnicodeSpaces(const string &query_str, string &new_query) {
+bool Parser::StripUnicodeSpaces(const string &query_str, string &new_query) {
 	const idx_t NBSP_LEN = 2;
 	const idx_t USP_LEN = 3;
 	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() {