duckdb 0.8.0 → 0.8.1-dev111.0

package/src/duckdb/src/planner/binder/statement/bind_create.cpp

@@ -243,18 +243,26 @@ void Binder::BindLogicalType(ClientContext &context, LogicalType &type, optional
 		type = LogicalType::UNION(member_types);
 		type.SetAlias(alias);
 	} else if (type.id() == LogicalTypeId::USER) {
-		auto &user_type_name = UserType::GetTypeName(type);
+		auto user_type_name = UserType::GetTypeName(type);
 		if (catalog) {
+			// The search order is:
+			// 1) In the same schema as the table
+			// 2) In the same catalog
+			// 3) System catalog
 			type = catalog->GetType(context, schema, user_type_name, OnEntryNotFound::RETURN_NULL);
+
 			if (type.id() == LogicalTypeId::INVALID) {
-				// look in the system catalog if the type was not found
-				type = Catalog::GetType(context, SYSTEM_CATALOG, schema, user_type_name);
+				type = catalog->GetType(context, INVALID_SCHEMA, user_type_name, OnEntryNotFound::RETURN_NULL);
+			}
+
+			if (type.id() == LogicalTypeId::INVALID) {
+				type = Catalog::GetType(context, INVALID_CATALOG, schema, user_type_name);
 			}
 		} else {
 			type = Catalog::GetType(context, INVALID_CATALOG, schema, user_type_name);
 		}
 	} else if (type.id() == LogicalTypeId::ENUM) {
-		auto &enum_type_name = EnumType::GetTypeName(type);
+		auto enum_type_name = EnumType::GetTypeName(type);
 		optional_ptr<TypeCatalogEntry> enum_type_catalog;
 		if (catalog) {
 			enum_type_catalog =
@@ -493,7 +501,7 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 		result.plan = make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_SCHEMA, std::move(stmt.info));
 		break;
 	case CatalogType::VIEW_ENTRY: {
-		auto &base = (CreateViewInfo &)*stmt.info;
+		auto &base = stmt.info->Cast<CreateViewInfo>();
 		// bind the schema
 		auto &schema = BindCreateSchema(*stmt.info);
 		BindCreateViewInfo(base);

package/src/duckdb/src/planner/binder/statement/bind_insert.cpp

@@ -350,7 +350,7 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 		// Get the column_ids we need to fetch later on from the conflicting tuples
 		// of the original table, to execute the expressions
 		D_ASSERT(original_binding->binding_type == BindingType::TABLE);
-		auto &table_binding = (TableBinding &)*original_binding;
+		auto &table_binding = original_binding->Cast<TableBinding>();
 		insert.columns_to_fetch = table_binding.GetBoundColumnIds();
 		return;
 	}
@@ -376,7 +376,7 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 	// Get the column_ids we need to fetch later on from the conflicting tuples
 	// of the original table, to execute the expressions
 	D_ASSERT(original_binding->binding_type == BindingType::TABLE);
-	auto &table_binding = (TableBinding &)*original_binding;
+	auto &table_binding = original_binding->Cast<TableBinding>();
 	insert.columns_to_fetch = table_binding.GetBoundColumnIds();
 
 	// Replace the column bindings to refer to the child operator

package/src/duckdb/src/planner/binder/statement/bind_update.cpp

@@ -87,7 +87,7 @@ static void BindUpdateConstraints(TableCatalogEntry &table, LogicalGet &get, Log
 	// with a "useless" update (i.e. i=i) so we can verify that the CHECK constraint is not violated
 	for (auto &constraint : table.GetBoundConstraints()) {
 		if (constraint->type == ConstraintType::CHECK) {
-			auto &check = *reinterpret_cast<BoundCheckConstraint *>(constraint.get());
+			auto &check = constraint->Cast<BoundCheckConstraint>();
 			// check constraint! check if we need to add any extra columns to the UPDATE clause
 			BindExtraColumns(table, get, proj, update, check.bound_columns);
 		}

package/src/duckdb/src/planner/binder/tableref/bind_pivot.cpp

@@ -84,7 +84,7 @@ static unique_ptr<SelectNode> PivotInitialAggregate(PivotBindState &bind_state,
 			if (entry->type != ExpressionType::COLUMN_REF) {
 				throw InternalException("Unexpected child of pivot source - not a ColumnRef");
 			}
-			auto &columnref = (ColumnRefExpression &)*entry;
+			auto &columnref = entry->Cast<ColumnRefExpression>();
 			if (handled_columns.find(columnref.GetColumnName()) == handled_columns.end()) {
 				// not handled - add to grouping set
 				subquery_stage1->groups.group_expressions.push_back(

package/src/duckdb/src/planner/binder/tableref/bind_table_function.cpp

@@ -78,6 +78,15 @@ bool Binder::BindTableFunctionParameters(TableFunctionCatalogEntry &table_functi
 			}
 		}
 		if (child->type == ExpressionType::SUBQUERY) {
+			auto fun = table_function.functions.GetFunctionByOffset(0);
+			if (table_function.functions.Size() != 1 || fun.arguments.empty() ||
+			    fun.arguments[0].id() != LogicalTypeId::TABLE) {
+				throw BinderException(
+				    "Only table-in-out functions can have subquery parameters - %s only accepts constant parameters",
+				    fun.name);
+			}
+			// this separate subquery binding path is only used by python_map
+			// FIXME: this should be unified with `BindTableInTableOutFunction` above
 			if (seen_subquery) {
 				error = "Table function can have at most one subquery parameter ";
 				return false;
@@ -98,8 +107,8 @@ bool Binder::BindTableFunctionParameters(TableFunctionCatalogEntry &table_functi
 			throw ParameterNotResolvedException();
 		}
 		if (!expr->IsScalar()) {
-			error = "Table function requires a constant parameter";
-			return false;
+			// should have been eliminated before
+			throw InternalException("Table function requires a constant parameter");
 		}
 		auto constant = ExpressionExecutor::EvaluateScalar(context, *expr, true);
 		if (parameter_name.empty()) {
@@ -141,8 +150,8 @@ Binder::BindTableFunctionInternal(TableFunction &table_function, const string &f
 		}
 		bind_data = table_function.bind(context, bind_input, return_types, return_names);
 		if (table_function.name == "pandas_scan" || table_function.name == "arrow_scan") {
-			auto arrow_bind = (PyTableFunctionData *)bind_data.get();
-			arrow_bind->external_dependency = std::move(external_dependency);
+			auto &arrow_bind = bind_data->Cast<PyTableFunctionData>();
+			arrow_bind.external_dependency = std::move(external_dependency);
 		}
 		if (table_function.name == "read_csv" || table_function.name == "read_csv_auto") {
 			auto &csv_bind = bind_data->Cast<ReadCSVData>();
@@ -154,9 +163,7 @@ Binder::BindTableFunctionInternal(TableFunction &table_function, const string &f
 		}
 	}
 	if (return_types.size() != return_names.size()) {
-		throw InternalException(
-		    "Failed to bind \"%s\": Table function return_types and return_names must be of the same size",
-		    table_function.name);
+		throw InternalException("Failed to bind \"%s\": return_types/names must have same size", table_function.name);
 	}
 	if (return_types.empty()) {
 		throw InternalException("Failed to bind \"%s\": Table function must return at least one column",

package/src/duckdb/src/planner/binder.cpp

@@ -208,7 +208,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundTableRef &ref) {
 		root = CreatePlan(ref.Cast<BoundCTERef>());
 		break;
 	case TableReferenceType::PIVOT:
-		root = CreatePlan((BoundPivotRef &)ref);
+		root = CreatePlan(ref.Cast<BoundPivotRef>());
 		break;
 	case TableReferenceType::INVALID:
 	default:

package/src/duckdb/src/planner/bound_result_modifier.cpp

@@ -29,7 +29,7 @@ bool BoundOrderByNode::Equals(const BoundOrderByNode &other) const {
 	if (type != other.type || null_order != other.null_order) {
 		return false;
 	}
-	if (!expression->Equals(other.expression.get())) {
+	if (!expression->Equals(*other.expression)) {
 		return false;
 	}
 
@@ -88,24 +88,29 @@ unique_ptr<BoundOrderModifier> BoundOrderModifier::Copy() const {
 	return result;
 }
 
-bool BoundOrderModifier::Equals(const BoundOrderModifier *left, const BoundOrderModifier *right) {
-	if (left == right) {
-		return true;
-	}
-	if (!left || !right) {
+bool BoundOrderModifier::Equals(const BoundOrderModifier &left, const BoundOrderModifier &right) {
+	if (left.orders.size() != right.orders.size()) {
 		return false;
 	}
-	if (left->orders.size() != right->orders.size()) {
-		return false;
-	}
-	for (idx_t i = 0; i < left->orders.size(); i++) {
-		if (!left->orders[i].Equals(right->orders[i])) {
+	for (idx_t i = 0; i < left.orders.size(); i++) {
+		if (!left.orders[i].Equals(right.orders[i])) {
 			return false;
 		}
 	}
 	return true;
 }
 
+bool BoundOrderModifier::Equals(const unique_ptr<BoundOrderModifier> &left,
+                                const unique_ptr<BoundOrderModifier> &right) {
+	if (left.get() == right.get()) {
+		return true;
+	}
+	if (!left || !right) {
+		return false;
+	}
+	return BoundOrderModifier::Equals(*left, *right);
+}
+
 BoundLimitModifier::BoundLimitModifier() : BoundResultModifier(ResultModifierType::LIMIT_MODIFIER) {
 }
 

package/src/duckdb/src/planner/expression/bound_aggregate_expression.cpp

@@ -30,11 +30,11 @@ hash_t BoundAggregateExpression::Hash() const {
 	return result;
 }
 
-bool BoundAggregateExpression::Equals(const BaseExpression *other_p) const {
+bool BoundAggregateExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundAggregateExpression>();
+	auto &other = other_p.Cast<BoundAggregateExpression>();
 	if (other.aggr_type != aggr_type) {
 		return false;
 	}
@@ -44,18 +44,18 @@ bool BoundAggregateExpression::Equals(const BaseExpression *other_p) const {
 	if (children.size() != other.children.size()) {
 		return false;
 	}
-	if (!Expression::Equals(other.filter.get(), filter.get())) {
+	if (!Expression::Equals(other.filter, filter)) {
 		return false;
 	}
 	for (idx_t i = 0; i < children.size(); i++) {
-		if (!Expression::Equals(children[i].get(), other.children[i].get())) {
+		if (!Expression::Equals(*children[i], *other.children[i])) {
 			return false;
 		}
 	}
 	if (!FunctionData::Equals(bind_info.get(), other.bind_info.get())) {
 		return false;
 	}
-	if (!BoundOrderModifier::Equals(order_bys.get(), other.order_bys.get())) {
+	if (!BoundOrderModifier::Equals(order_bys, other.order_bys)) {
 		return false;
 	}
 	return true;

package/src/duckdb/src/planner/expression/bound_between_expression.cpp

@@ -15,18 +15,18 @@ string BoundBetweenExpression::ToString() const {
 	return BetweenExpression::ToString<BoundBetweenExpression, Expression>(*this);
 }
 
-bool BoundBetweenExpression::Equals(const BaseExpression *other_p) const {
+bool BoundBetweenExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundBetweenExpression>();
-	if (!Expression::Equals(input.get(), other.input.get())) {
+	auto &other = other_p.Cast<BoundBetweenExpression>();
+	if (!Expression::Equals(*input, *other.input)) {
 		return false;
 	}
-	if (!Expression::Equals(lower.get(), other.lower.get())) {
+	if (!Expression::Equals(*lower, *other.lower)) {
 		return false;
 	}
-	if (!Expression::Equals(upper.get(), other.upper.get())) {
+	if (!Expression::Equals(*upper, *other.upper)) {
 		return false;
 	}
 	return lower_inclusive == other.lower_inclusive && upper_inclusive == other.upper_inclusive;

package/src/duckdb/src/planner/expression/bound_case_expression.cpp

@@ -22,23 +22,23 @@ string BoundCaseExpression::ToString() const {
 	return CaseExpression::ToString<BoundCaseExpression, Expression>(*this);
 }
 
-bool BoundCaseExpression::Equals(const BaseExpression *other_p) const {
+bool BoundCaseExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundCaseExpression>();
+	auto &other = other_p.Cast<BoundCaseExpression>();
 	if (case_checks.size() != other.case_checks.size()) {
 		return false;
 	}
 	for (idx_t i = 0; i < case_checks.size(); i++) {
-		if (!Expression::Equals(case_checks[i].when_expr.get(), other.case_checks[i].when_expr.get())) {
+		if (!Expression::Equals(*case_checks[i].when_expr, *other.case_checks[i].when_expr)) {
 			return false;
 		}
-		if (!Expression::Equals(case_checks[i].then_expr.get(), other.case_checks[i].then_expr.get())) {
+		if (!Expression::Equals(*case_checks[i].then_expr, *other.case_checks[i].then_expr)) {
 			return false;
 		}
 	}
-	if (!Expression::Equals(else_expr.get(), other.else_expr.get())) {
+	if (!Expression::Equals(*else_expr, *other.else_expr)) {
 		return false;
 	}
 	return true;

package/src/duckdb/src/planner/expression/bound_cast_expression.cpp

@@ -169,12 +169,12 @@ string BoundCastExpression::ToString() const {
 	return (try_cast ? "TRY_CAST(" : "CAST(") + child->GetName() + " AS " + return_type.ToString() + ")";
 }
 
-bool BoundCastExpression::Equals(const BaseExpression *other_p) const {
+bool BoundCastExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundCastExpression>();
-	if (!Expression::Equals(child.get(), other.child.get())) {
+	auto &other = other_p.Cast<BoundCastExpression>();
+	if (!Expression::Equals(*child, *other.child)) {
 		return false;
 	}
 	if (try_cast != other.try_cast) {

package/src/duckdb/src/planner/expression/bound_columnref_expression.cpp

@@ -27,11 +27,11 @@ hash_t BoundColumnRefExpression::Hash() const {
 	return CombineHash(result, duckdb::Hash<uint64_t>(depth));
 }
 
-bool BoundColumnRefExpression::Equals(const BaseExpression *other_p) const {
+bool BoundColumnRefExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundColumnRefExpression>();
+	auto &other = other_p.Cast<BoundColumnRefExpression>();
 	return other.binding == binding && other.depth == depth;
 }
 

package/src/duckdb/src/planner/expression/bound_comparison_expression.cpp

@@ -14,15 +14,15 @@ string BoundComparisonExpression::ToString() const {
 	return ComparisonExpression::ToString<BoundComparisonExpression, Expression>(*this);
 }
 
-bool BoundComparisonExpression::Equals(const BaseExpression *other_p) const {
+bool BoundComparisonExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundComparisonExpression>();
-	if (!Expression::Equals(left.get(), other.left.get())) {
+	auto &other = other_p.Cast<BoundComparisonExpression>();
+	if (!Expression::Equals(*left, *other.left)) {
 		return false;
 	}
-	if (!Expression::Equals(right.get(), other.right.get())) {
+	if (!Expression::Equals(*right, *other.right)) {
 		return false;
 	}
 	return true;

package/src/duckdb/src/planner/expression/bound_conjunction_expression.cpp

@@ -20,11 +20,11 @@ string BoundConjunctionExpression::ToString() const {
 	return ConjunctionExpression::ToString<BoundConjunctionExpression, Expression>(*this);
 }
 
-bool BoundConjunctionExpression::Equals(const BaseExpression *other_p) const {
+bool BoundConjunctionExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundConjunctionExpression>();
+	auto &other = other_p.Cast<BoundConjunctionExpression>();
 	return ExpressionUtil::SetEquals(children, other.children);
 }
 

package/src/duckdb/src/planner/expression/bound_constant_expression.cpp

@@ -14,11 +14,11 @@ string BoundConstantExpression::ToString() const {
 	return value.ToSQLString();
 }
 
-bool BoundConstantExpression::Equals(const BaseExpression *other_p) const {
+bool BoundConstantExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundConstantExpression>();
+	auto &other = other_p.Cast<BoundConstantExpression>();
 	return value.type() == other.value.type() && !ValueOperations::DistinctFrom(value, other.value);
 }
 

package/src/duckdb/src/planner/expression/bound_expression.cpp

@@ -22,7 +22,7 @@ string BoundExpression::ToString() const {
 	return expr->ToString();
 }
 
-bool BoundExpression::Equals(const BaseExpression *other) const {
+bool BoundExpression::Equals(const BaseExpression &other) const {
 	return false;
 }
 hash_t BoundExpression::Hash() const {

package/src/duckdb/src/planner/expression/bound_function_expression.cpp

@@ -2,7 +2,6 @@
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
 #include "duckdb/common/types/hash.hpp"
-#include "duckdb/parser/expression_util.hpp"
 #include "duckdb/function/function_serialization.hpp"
 
 namespace duckdb {
@@ -39,15 +38,15 @@ hash_t BoundFunctionExpression::Hash() const {
 	return CombineHash(result, function.Hash());
 }
 
-bool BoundFunctionExpression::Equals(const BaseExpression *other_p) const {
+bool BoundFunctionExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundFunctionExpression>();
+	auto &other = other_p.Cast<BoundFunctionExpression>();
 	if (other.function != function) {
 		return false;
 	}
-	if (!ExpressionUtil::ListEquals(children, other.children)) {
+	if (!Expression::ListEquals(children, other.children)) {
 		return false;
 	}
 	if (!FunctionData::Equals(bind_info.get(), other.bind_info.get())) {

package/src/duckdb/src/planner/expression/bound_lambda_expression.cpp

@@ -1,6 +1,5 @@
 #include "duckdb/planner/expression/bound_lambda_expression.hpp"
 #include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/expression_util.hpp"
 
 namespace duckdb {
 
@@ -14,15 +13,15 @@ string BoundLambdaExpression::ToString() const {
 	return lambda_expr->ToString();
 }
 
-bool BoundLambdaExpression::Equals(const BaseExpression *other_p) const {
+bool BoundLambdaExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundLambdaExpression>();
-	if (!Expression::Equals(lambda_expr.get(), other.lambda_expr.get())) {
+	auto &other = other_p.Cast<BoundLambdaExpression>();
+	if (!Expression::Equals(*lambda_expr, *other.lambda_expr)) {
 		return false;
 	}
-	if (!ExpressionUtil::ListEquals(captures, other.captures)) {
+	if (!Expression::ListEquals(captures, other.captures)) {
 		return false;
 	}
 	if (parameter_count != other.parameter_count) {

package/src/duckdb/src/planner/expression/bound_lambdaref_expression.cpp

@@ -30,11 +30,11 @@ hash_t BoundLambdaRefExpression::Hash() const {
 	return CombineHash(result, duckdb::Hash<uint64_t>(depth));
 }
 
-bool BoundLambdaRefExpression::Equals(const BaseExpression *other_p) const {
+bool BoundLambdaRefExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundLambdaRefExpression>();
+	auto &other = other_p.Cast<BoundLambdaRefExpression>();
 	return other.binding == binding && other.lambda_index == lambda_index && other.depth == depth;
 }
 

package/src/duckdb/src/planner/expression/bound_operator_expression.cpp

@@ -1,6 +1,5 @@
 #include "duckdb/planner/expression/bound_operator_expression.hpp"
 #include "duckdb/common/string_util.hpp"
-#include "duckdb/parser/expression_util.hpp"
 #include "duckdb/parser/expression/operator_expression.hpp"
 #include "duckdb/common/field_writer.hpp"
 
@@ -14,12 +13,12 @@ string BoundOperatorExpression::ToString() const {
 	return OperatorExpression::ToString<BoundOperatorExpression, Expression>(*this);
 }
 
-bool BoundOperatorExpression::Equals(const BaseExpression *other_p) const {
+bool BoundOperatorExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundOperatorExpression>();
-	if (!ExpressionUtil::ListEquals(children, other.children)) {
+	auto &other = other_p.Cast<BoundOperatorExpression>();
+	if (!Expression::ListEquals(children, other.children)) {
 		return false;
 	}
 	return true;

package/src/duckdb/src/planner/expression/bound_parameter_expression.cpp

@@ -43,11 +43,11 @@ string BoundParameterExpression::ToString() const {
 	return "$" + to_string(parameter_nr);
 }
 
-bool BoundParameterExpression::Equals(const BaseExpression *other_p) const {
+bool BoundParameterExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundParameterExpression>();
+	auto &other = other_p.Cast<BoundParameterExpression>();
 	return parameter_nr == other.parameter_nr;
 }
 

package/src/duckdb/src/planner/expression/bound_reference_expression.cpp

@@ -28,11 +28,11 @@ string BoundReferenceExpression::ToString() const {
 	return "#" + to_string(index);
 }
 
-bool BoundReferenceExpression::Equals(const BaseExpression *other_p) const {
+bool BoundReferenceExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundReferenceExpression>();
+	auto &other = other_p.Cast<BoundReferenceExpression>();
 	return other.index == index;
 }
 

package/src/duckdb/src/planner/expression/bound_subquery_expression.cpp

@@ -12,7 +12,7 @@ string BoundSubqueryExpression::ToString() const {
 	return "SUBQUERY";
 }
 
-bool BoundSubqueryExpression::Equals(const BaseExpression *other_p) const {
+bool BoundSubqueryExpression::Equals(const BaseExpression &other_p) const {
 	// equality between bound subqueries not implemented currently
 	return false;
 }

package/src/duckdb/src/planner/expression/bound_unnest_expression.cpp

@@ -23,12 +23,12 @@ hash_t BoundUnnestExpression::Hash() const {
 	return CombineHash(result, duckdb::Hash("unnest"));
 }
 
-bool BoundUnnestExpression::Equals(const BaseExpression *other_p) const {
+bool BoundUnnestExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundUnnestExpression>();
-	if (!Expression::Equals(child.get(), other.child.get())) {
+	auto &other = other_p.Cast<BoundUnnestExpression>();
+	if (!Expression::Equals(*child, *other.child)) {
 		return false;
 	}
 	return true;

package/src/duckdb/src/planner/expression/bound_window_expression.cpp

@@ -21,11 +21,11 @@ string BoundWindowExpression::ToString() const {
 	                                                                                       function_name);
 }
 
-bool BoundWindowExpression::Equals(const BaseExpression *other_p) const {
+bool BoundWindowExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::Equals(other_p)) {
 		return false;
 	}
-	auto &other = other_p->Cast<BoundWindowExpression>();
+	auto &other = other_p.Cast<BoundWindowExpression>();
 
 	if (ignore_nulls != other.ignore_nulls) {
 		return false;
@@ -34,24 +34,17 @@ bool BoundWindowExpression::Equals(const BaseExpression *other_p) const {
 		return false;
 	}
 	// check if the child expressions are equivalent
-	if (other.children.size() != children.size()) {
+	if (!Expression::ListEquals(children, other.children)) {
 		return false;
 	}
-	for (idx_t i = 0; i < children.size(); i++) {
-		if (!Expression::Equals(children[i].get(), other.children[i].get())) {
-			return false;
-		}
-	}
 	// check if the filter expressions are equivalent
-	if (!Expression::Equals(filter_expr.get(), other.filter_expr.get())) {
+	if (!Expression::Equals(filter_expr, other.filter_expr)) {
 		return false;
 	}
 
 	// check if the framing expressions are equivalent
-	if (!Expression::Equals(start_expr.get(), other.start_expr.get()) ||
-	    !Expression::Equals(end_expr.get(), other.end_expr.get()) ||
-	    !Expression::Equals(offset_expr.get(), other.offset_expr.get()) ||
-	    !Expression::Equals(default_expr.get(), other.default_expr.get())) {
+	if (!Expression::Equals(start_expr, other.start_expr) || !Expression::Equals(end_expr, other.end_expr) ||
+	    !Expression::Equals(offset_expr, other.offset_expr) || !Expression::Equals(default_expr, other.default_expr)) {
 		return false;
 	}
 
@@ -60,14 +53,9 @@ bool BoundWindowExpression::Equals(const BaseExpression *other_p) const {
 
 bool BoundWindowExpression::KeysAreCompatible(const BoundWindowExpression &other) const {
 	// check if the partitions are equivalent
-	if (partitions.size() != other.partitions.size()) {
+	if (!Expression::ListEquals(partitions, other.partitions)) {
 		return false;
 	}
-	for (idx_t i = 0; i < partitions.size(); i++) {
-		if (!Expression::Equals(partitions[i].get(), other.partitions[i].get())) {
-			return false;
-		}
-	}
 	// check if the orderings are equivalent
 	if (orders.size() != other.orders.size()) {
 		return false;
@@ -76,8 +64,7 @@ bool BoundWindowExpression::KeysAreCompatible(const BoundWindowExpression &other
 		if (orders[i].type != other.orders[i].type) {
 			return false;
 		}
-		if (!BaseExpression::Equals((BaseExpression *)orders[i].expression.get(),
-		                            (BaseExpression *)other.orders[i].expression.get())) {
+		if (!Expression::Equals(*orders[i].expression, *other.orders[i].expression)) {
 			return false;
 		}
 	}

package/src/duckdb/src/planner/expression.cpp

@@ -6,6 +6,7 @@
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/storage/statistics/base_statistics.hpp"
 #include "duckdb/planner/expression/list.hpp"
+#include "duckdb/parser/expression_util.hpp"
 
 namespace duckdb {
 
@@ -165,4 +166,18 @@ unique_ptr<Expression> Expression::Deserialize(Deserializer &source, PlanDeseria
 	return result;
 }
 
+bool Expression::Equals(const unique_ptr<Expression> &left, const unique_ptr<Expression> &right) {
+	if (left.get() == right.get()) {
+		return true;
+	}
+	if (!left || !right) {
+		return false;
+	}
+	return left->Equals(*right);
+}
+
+bool Expression::ListEquals(const vector<unique_ptr<Expression>> &left, const vector<unique_ptr<Expression>> &right) {
+	return ExpressionUtil::ListEquals(left, right);
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/expression_binder/base_select_binder.cpp

@@ -62,8 +62,8 @@ idx_t BaseSelectBinder::TryBindGroup(ParsedExpression &expr, idx_t depth) {
 	}
 #ifdef DEBUG
 	for (auto entry : info.map) {
-		D_ASSERT(!entry.first.get().Equals(&expr));
-		D_ASSERT(!expr.Equals(&entry.first.get()));
+		D_ASSERT(!entry.first.get().Equals(expr));
+		D_ASSERT(!expr.Equals(entry.first.get()));
 	}
 #endif
 	return DConstants::INVALID_INDEX;

package/src/duckdb/src/planner/expression_iterator.cpp

@@ -230,12 +230,12 @@ void ExpressionIterator::EnumerateQueryNodeChildren(BoundQueryNode &node,
 	for (idx_t i = 0; i < node.modifiers.size(); i++) {
 		switch (node.modifiers[i]->type) {
 		case ResultModifierType::DISTINCT_MODIFIER:
-			for (auto &expr : ((BoundDistinctModifier &)*node.modifiers[i]).target_distincts) {
+			for (auto &expr : node.modifiers[i]->Cast<BoundDistinctModifier>().target_distincts) {
 				EnumerateExpression(expr, callback);
 			}
 			break;
 		case ResultModifierType::ORDER_MODIFIER:
-			for (auto &order : ((BoundOrderModifier &)*node.modifiers[i]).orders) {
+			for (auto &order : node.modifiers[i]->Cast<BoundOrderModifier>().orders) {
 				EnumerateExpression(order.expression, callback);
 			}
 			break;