duckdb 0.8.1-dev65.0 → 0.8.1

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

@@ -1,18 +1,17 @@
 #include "duckdb/parser/parser.hpp"
 
-#include "duckdb/parser/transformer.hpp"
 #include "duckdb/parser/parsed_data/create_table_info.hpp"
+#include "duckdb/parser/parser_extension.hpp"
+#include "duckdb/parser/query_error_context.hpp"
+#include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/statement/create_statement.hpp"
 #include "duckdb/parser/statement/extension_statement.hpp"
 #include "duckdb/parser/statement/select_statement.hpp"
 #include "duckdb/parser/statement/update_statement.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/tableref/expressionlistref.hpp"
-#include "postgres_parser.hpp"
-#include "duckdb/parser/query_error_context.hpp"
-#include "duckdb/parser/parser_extension.hpp"
-
+#include "duckdb/parser/transformer.hpp"
 #include "parser/parser.hpp"
+#include "postgres_parser.hpp"
 
 namespace duckdb {
 
@@ -45,13 +44,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:
@@ -124,6 +123,29 @@ end:
 	return ReplaceUnicodeSpaces(query_str, new_query, unicode_spaces);
 }
 
+vector<string> SplitQueryStringIntoStatements(const string &query) {
+	// Break sql string down into sql statements using the tokenizer
+	vector<string> query_statements;
+	auto tokens = Parser::Tokenize(query);
+	auto next_statement_start = 0;
+	for (idx_t i = 1; i < tokens.size(); ++i) {
+		auto &t_prev = tokens[i - 1];
+		auto &t = tokens[i];
+		if (t_prev.type == SimplifiedTokenType::SIMPLIFIED_TOKEN_OPERATOR) {
+			// LCOV_EXCL_START
+			for (idx_t c = t_prev.start; c <= t.start; ++c) {
+				if (query.c_str()[c] == ';') {
+					query_statements.emplace_back(query.substr(next_statement_start, t.start - next_statement_start));
+					next_statement_start = tokens[i].start;
+				}
+			}
+			// LCOV_EXCL_STOP
+		}
+	}
+	query_statements.emplace_back(query.substr(next_statement_start, query.size() - next_statement_start));
+	return query_statements;
+}
+
 void Parser::ParseQuery(const string &query) {
 	Transformer transformer(options);
 	string parser_error;
@@ -138,39 +160,77 @@ void Parser::ParseQuery(const string &query) {
 	}
 	{
 		PostgresParser::SetPreserveIdentifierCase(options.preserve_identifier_case);
-		PostgresParser parser;
-		parser.Parse(query);
-		if (parser.success) {
-			if (!parser.parse_tree) {
-				// empty statement
-				return;
-			}
-
-			// if it succeeded, we transform the Postgres parse tree into a list of
-			// SQLStatements
-			transformer.TransformParseTree(parser.parse_tree, statements);
-		} else {
-			parser_error = QueryErrorContext::Format(query, parser.error_message, parser.error_location - 1);
-		}
-	}
-	if (!parser_error.empty()) {
-		if (options.extensions) {
-			for (auto &ext : *options.extensions) {
-				D_ASSERT(ext.parse_function);
-				auto result = ext.parse_function(ext.parser_info.get(), query);
-				if (result.type == ParserExtensionResultType::PARSE_SUCCESSFUL) {
-					auto statement = make_uniq<ExtensionStatement>(ext, std::move(result.parse_data));
-					statement->stmt_length = query.size();
-					statement->stmt_location = 0;
-					statements.push_back(std::move(statement));
+		bool parsing_succeed = false;
+		// Creating a new scope to prevent multiple PostgresParser destructors being called
+		// which led to some memory issues
+		{
+			PostgresParser parser;
+			parser.Parse(query);
+			if (parser.success) {
+				if (!parser.parse_tree) {
+					// empty statement
 					return;
 				}
-				if (result.type == ParserExtensionResultType::DISPLAY_EXTENSION_ERROR) {
-					throw ParserException(result.error);
+
+				// if it succeeded, we transform the Postgres parse tree into a list of
+				// SQLStatements
+				transformer.TransformParseTree(parser.parse_tree, statements);
+				parsing_succeed = true;
+			} else {
+				parser_error = QueryErrorContext::Format(query, parser.error_message, parser.error_location - 1);
+			}
+		}
+		// If DuckDB fails to parse the entire sql string, break the string down into individual statements
+		// using ';' as the delimiter so that parser extensions can parse the statement
+		if (parsing_succeed) {
+			// no-op
+			// return here would require refactoring into another function. o.w. will just no-op in order to run wrap up
+			// code at the end of this function
+		} else if (!options.extensions || options.extensions->empty()) {
+			throw ParserException(parser_error);
+		} else {
+			// split sql string into statements and re-parse using extension
+			auto query_statements = SplitQueryStringIntoStatements(query);
+			for (auto const &query_statement : query_statements) {
+				PostgresParser another_parser;
+				another_parser.Parse(query_statement);
+				// LCOV_EXCL_START
+				// first see if DuckDB can parse this individual query statement
+				if (another_parser.success) {
+					if (!another_parser.parse_tree) {
+						// empty statement
+						continue;
+					}
+					transformer.TransformParseTree(another_parser.parse_tree, statements);
+				} else {
+					// let extensions parse the statement which DuckDB failed to parse
+					bool parsed_single_statement = false;
+					for (auto &ext : *options.extensions) {
+						D_ASSERT(!parsed_single_statement);
+						D_ASSERT(ext.parse_function);
+						auto result = ext.parse_function(ext.parser_info.get(), query_statement);
+						if (result.type == ParserExtensionResultType::PARSE_SUCCESSFUL) {
+							auto statement = make_uniq<ExtensionStatement>(ext, std::move(result.parse_data));
+							statement->stmt_length = query_statement.size();
+							statement->stmt_location = 0;
+							statements.push_back(std::move(statement));
+							parsed_single_statement = true;
+							break;
+						} else if (result.type == ParserExtensionResultType::DISPLAY_EXTENSION_ERROR) {
+							throw ParserException(result.error);
+						} else {
+							// We move to the next one!
+						}
+					}
+					if (!parsed_single_statement) {
+						parser_error = QueryErrorContext::Format(query, another_parser.error_message,
+						                                         another_parser.error_location - 1);
+						throw ParserException(parser_error);
+					}
 				}
+				// LCOV_EXCL_STOP
 			}
 		}
-		throw ParserException(parser_error);
 	}
 	if (!statements.empty()) {
 		auto &last_statement = statements.back();
@@ -288,7 +348,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 +401,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() {