duckdb 0.8.1-dev23.0 → 0.8.1-dev253.0

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

@@ -4,11 +4,16 @@
 
 namespace duckdb {
 
-BindResult ExpressionBinder::BindExpression(PositionalReferenceExpression &ref, idx_t depth) {
+BindResult ExpressionBinder::BindPositionalReference(unique_ptr<ParsedExpression> &expr, idx_t depth,
+                                                     bool root_expression) {
+	auto &ref = expr->Cast<PositionalReferenceExpression>();
 	if (depth != 0) {
-		return BindResult("Positional reference expression could not be bound");
+		throw InternalException("Positional reference expression could not be bound");
 	}
-	return binder.bind_context.BindColumn(ref, depth);
+	// replace the positional reference with a column
+	auto column = binder.bind_context.PositionToColumn(ref);
+	expr = std::move(column);
+	return BindExpression(expr, depth, root_expression);
 }
 
 } // namespace duckdb

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

@@ -55,7 +55,7 @@ bool Binder::FindStarExpression(unique_ptr<ParsedExpression> &expr, StarExpressi
 		in_columns = true;
 		if (*star) {
 			// we can have multiple
-			if (!StarExpression::Equal(*star, &current_star)) {
+			if (!(*star)->Equals(current_star)) {
 				throw BinderException(
 				    FormatError(*expr, "Multiple different STAR/COLUMNS in the same expression are not supported"));
 			}

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

@@ -8,6 +8,9 @@
 namespace duckdb {
 
 class BoundSubqueryNode : public QueryNode {
+public:
+	static constexpr const QueryNodeType TYPE = QueryNodeType::BOUND_SUBQUERY_NODE;
+
 public:
 	BoundSubqueryNode(shared_ptr<Binder> subquery_binder, unique_ptr<BoundQueryNode> bound_node,
 	                  unique_ptr<SelectStatement> subquery)
@@ -74,9 +77,9 @@ BindResult ExpressionBinder::BindExpression(SubqueryExpression &expr, idx_t dept
 	}
 	// both binding the child and binding the subquery was successful
 	D_ASSERT(expr.subquery->node->type == QueryNodeType::BOUND_SUBQUERY_NODE);
-	auto bound_subquery = (BoundSubqueryNode *)expr.subquery->node.get();
-	auto subquery_binder = std::move(bound_subquery->subquery_binder);
-	auto bound_node = std::move(bound_subquery->bound_node);
+	auto &bound_subquery = expr.subquery->node->Cast<BoundSubqueryNode>();
+	auto subquery_binder = std::move(bound_subquery.subquery_binder);
+	auto bound_node = std::move(bound_subquery.bound_node);
 	LogicalType return_type =
 	    expr.subquery_type == SubqueryType::SCALAR ? bound_node->types[0] : LogicalType(LogicalTypeId::BOOLEAN);
 	if (return_type.id() == LogicalTypeId::UNKNOWN) {

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

@@ -113,7 +113,7 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 		unique_ptr<BoundResultModifier> bound_modifier;
 		switch (mod->type) {
 		case ResultModifierType::DISTINCT_MODIFIER: {
-			auto &distinct = (DistinctModifier &)*mod;
+			auto &distinct = mod->Cast<DistinctModifier>();
 			auto bound_distinct = make_uniq<BoundDistinctModifier>();
 			bound_distinct->distinct_type =
 			    distinct.distinct_on_targets.empty() ? DistinctType::DISTINCT : DistinctType::DISTINCT_ON;
@@ -133,7 +133,7 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 			break;
 		}
 		case ResultModifierType::ORDER_MODIFIER: {
-			auto &order = (OrderModifier &)*mod;
+			auto &order = mod->Cast<OrderModifier>();
 			auto bound_order = make_uniq<BoundOrderModifier>();
 			auto &config = DBConfig::GetConfig(context);
 			D_ASSERT(!order.orders.empty());
@@ -174,10 +174,10 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 			break;
 		}
 		case ResultModifierType::LIMIT_MODIFIER:
-			bound_modifier = BindLimit(order_binder, (LimitModifier &)*mod);
+			bound_modifier = BindLimit(order_binder, mod->Cast<LimitModifier>());
 			break;
 		case ResultModifierType::LIMIT_PERCENT_MODIFIER:
-			bound_modifier = BindLimitPercent(order_binder, (LimitPercentModifier &)*mod);
+			bound_modifier = BindLimitPercent(order_binder, mod->Cast<LimitPercentModifier>());
 			break;
 		default:
 			throw Exception("Unsupported result modifier");
@@ -203,7 +203,7 @@ void Binder::BindModifierTypes(BoundQueryNode &result, const vector<LogicalType>
 	for (auto &bound_mod : result.modifiers) {
 		switch (bound_mod->type) {
 		case ResultModifierType::DISTINCT_MODIFIER: {
-			auto &distinct = (BoundDistinctModifier &)*bound_mod;
+			auto &distinct = bound_mod->Cast<BoundDistinctModifier>();
 			D_ASSERT(!distinct.target_distincts.empty());
 			// set types of distinct targets
 			for (auto &expr : distinct.target_distincts) {
@@ -226,19 +226,19 @@ void Binder::BindModifierTypes(BoundQueryNode &result, const vector<LogicalType>
 			break;
 		}
 		case ResultModifierType::LIMIT_MODIFIER: {
-			auto &limit = (BoundLimitModifier &)*bound_mod;
+			auto &limit = bound_mod->Cast<BoundLimitModifier>();
 			AssignReturnType(limit.limit, sql_types);
 			AssignReturnType(limit.offset, sql_types);
 			break;
 		}
 		case ResultModifierType::LIMIT_PERCENT_MODIFIER: {
-			auto &limit = (BoundLimitPercentModifier &)*bound_mod;
+			auto &limit = bound_mod->Cast<BoundLimitPercentModifier>();
 			AssignReturnType(limit.limit, sql_types);
 			AssignReturnType(limit.offset, sql_types);
 			break;
 		}
 		case ResultModifierType::ORDER_MODIFIER: {
-			auto &order = (BoundOrderModifier &)*bound_mod;
+			auto &order = bound_mod->Cast<BoundOrderModifier>();
 			for (auto &order_node : order.orders) {
 				auto &expr = order_node.expression;
 				D_ASSERT(expr->type == ExpressionType::BOUND_COLUMN_REF);

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

@@ -13,14 +13,14 @@ unique_ptr<LogicalOperator> Binder::VisitQueryNode(BoundQueryNode &node, unique_
 	for (auto &mod : node.modifiers) {
 		switch (mod->type) {
 		case ResultModifierType::DISTINCT_MODIFIER: {
-			auto &bound = (BoundDistinctModifier &)*mod;
+			auto &bound = mod->Cast<BoundDistinctModifier>();
 			auto distinct = make_uniq<LogicalDistinct>(std::move(bound.target_distincts), bound.distinct_type);
 			distinct->AddChild(std::move(root));
 			root = std::move(distinct);
 			break;
 		}
 		case ResultModifierType::ORDER_MODIFIER: {
-			auto &bound = (BoundOrderModifier &)*mod;
+			auto &bound = mod->Cast<BoundOrderModifier>();
 			if (root->type == LogicalOperatorType::LOGICAL_DISTINCT) {
 				auto &distinct = root->Cast<LogicalDistinct>();
 				if (distinct.distinct_type == DistinctType::DISTINCT_ON) {
@@ -37,7 +37,7 @@ unique_ptr<LogicalOperator> Binder::VisitQueryNode(BoundQueryNode &node, unique_
 			break;
 		}
 		case ResultModifierType::LIMIT_MODIFIER: {
-			auto &bound = (BoundLimitModifier &)*mod;
+			auto &bound = mod->Cast<BoundLimitModifier>();
 			auto limit = make_uniq<LogicalLimit>(bound.limit_val, bound.offset_val, std::move(bound.limit),
 			                                     std::move(bound.offset));
 			limit->AddChild(std::move(root));
@@ -45,7 +45,7 @@ unique_ptr<LogicalOperator> Binder::VisitQueryNode(BoundQueryNode &node, unique_
 			break;
 		}
 		case ResultModifierType::LIMIT_PERCENT_MODIFIER: {
-			auto &bound = (BoundLimitPercentModifier &)*mod;
+			auto &bound = mod->Cast<BoundLimitPercentModifier>();
 			auto limit = make_uniq<LogicalLimitPercent>(bound.limit_percent, bound.offset_val, std::move(bound.limit),
 			                                            std::move(bound.offset));
 			limit->AddChild(std::move(root));

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

@@ -501,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_create_table.cpp

@@ -294,9 +294,26 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 		BindLogicalType(context, column.TypeMutable(), &result->schema.catalog);
 		// We add a catalog dependency
 		auto type_dependency = EnumType::GetCatalog(column.Type());
+
 		if (type_dependency) {
 			// Only if the USER comes from a create type
-			result->dependencies.AddDependency(*type_dependency);
+			if (!schema.catalog.IsTemporaryCatalog()) {
+				// If it is not a TEMP table we add a dependency
+				result->dependencies.AddDependency(*type_dependency);
+			} else {
+				auto enum_type = type_dependency->user_type;
+				auto &enum_entries = EnumType::GetValuesInsertOrder(enum_type);
+				auto enum_size = EnumType::GetSize(enum_type);
+				Vector copy_enum_entries_vec(LogicalType::VARCHAR, enum_size);
+				auto copy_enum_entries_ptr = FlatVector::GetData<string_t>(copy_enum_entries_vec);
+				auto enum_entries_ptr = FlatVector::GetData<string_t>(enum_entries);
+				for (idx_t enum_idx = 0; enum_idx < enum_size; enum_idx++) {
+					copy_enum_entries_ptr[enum_idx] =
+					    StringVector::AddStringOrBlob(copy_enum_entries_vec, enum_entries_ptr[enum_idx]);
+				}
+				auto copy_type = LogicalType::ENUM(EnumType::GetTypeName(enum_type), copy_enum_entries_vec, enum_size);
+				column.SetType(copy_type);
+			}
 		}
 	}
 	result->dependencies.VerifyDependencies(schema.catalog, result->Base().table);

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

@@ -20,119 +20,6 @@
 
 namespace duckdb {
 
-static void BindExtraColumns(TableCatalogEntry &table, LogicalGet &get, LogicalProjection &proj, LogicalUpdate &update,
-                             physical_index_set_t &bound_columns) {
-	if (bound_columns.size() <= 1) {
-		return;
-	}
-	idx_t found_column_count = 0;
-	physical_index_set_t found_columns;
-	for (idx_t i = 0; i < update.columns.size(); i++) {
-		if (bound_columns.find(update.columns[i]) != bound_columns.end()) {
-			// this column is referenced in the CHECK constraint
-			found_column_count++;
-			found_columns.insert(update.columns[i]);
-		}
-	}
-	if (found_column_count > 0 && found_column_count != bound_columns.size()) {
-		// columns in this CHECK constraint were referenced, but not all were part of the UPDATE
-		// add them to the scan and update set
-		for (auto &check_column_id : bound_columns) {
-			if (found_columns.find(check_column_id) != found_columns.end()) {
-				// column is already projected
-				continue;
-			}
-			// column is not projected yet: project it by adding the clause "i=i" to the set of updated columns
-			auto &column = table.GetColumns().GetColumn(check_column_id);
-			update.expressions.push_back(make_uniq<BoundColumnRefExpression>(
-			    column.Type(), ColumnBinding(proj.table_index, proj.expressions.size())));
-			proj.expressions.push_back(make_uniq<BoundColumnRefExpression>(
-			    column.Type(), ColumnBinding(get.table_index, get.column_ids.size())));
-			get.column_ids.push_back(check_column_id.index);
-			update.columns.push_back(check_column_id);
-		}
-	}
-}
-
-static bool TypeSupportsRegularUpdate(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::LIST:
-	case LogicalTypeId::MAP:
-	case LogicalTypeId::UNION:
-		// lists and maps and unions don't support updates directly
-		return false;
-	case LogicalTypeId::STRUCT: {
-		auto &child_types = StructType::GetChildTypes(type);
-		for (auto &entry : child_types) {
-			if (!TypeSupportsRegularUpdate(entry.second)) {
-				return false;
-			}
-		}
-		return true;
-	}
-	default:
-		return true;
-	}
-}
-
-static void BindUpdateConstraints(TableCatalogEntry &table, LogicalGet &get, LogicalProjection &proj,
-                                  LogicalUpdate &update) {
-	if (!table.IsDuckTable()) {
-		return;
-	}
-	// check the constraints and indexes of the table to see if we need to project any additional columns
-	// we do this for indexes with multiple columns and CHECK constraints in the UPDATE clause
-	// suppose we have a constraint CHECK(i + j < 10); now we need both i and j to check the constraint
-	// if we are only updating one of the two columns we add the other one to the UPDATE set
-	// 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());
-			// check constraint! check if we need to add any extra columns to the UPDATE clause
-			BindExtraColumns(table, get, proj, update, check.bound_columns);
-		}
-	}
-	auto &storage = table.GetStorage();
-	if (update.return_chunk) {
-		physical_index_set_t all_columns;
-		for (idx_t i = 0; i < storage.column_definitions.size(); i++) {
-			all_columns.insert(PhysicalIndex(i));
-		}
-		BindExtraColumns(table, get, proj, update, all_columns);
-	}
-	// for index updates we always turn any update into an insert and a delete
-	// we thus need all the columns to be available, hence we check if the update touches any index columns
-	// If the returning keyword is used, we need access to the whole row in case the user requests it.
-	// Therefore switch the update to a delete and insert.
-	update.update_is_del_and_insert = false;
-	storage.info->indexes.Scan([&](Index &index) {
-		if (index.IndexIsUpdated(update.columns)) {
-			update.update_is_del_and_insert = true;
-			return true;
-		}
-		return false;
-	});
-
-	// we also convert any updates on LIST columns into delete + insert
-	for (auto &col_index : update.columns) {
-		auto &column = table.GetColumns().GetColumn(col_index);
-		if (!TypeSupportsRegularUpdate(column.Type())) {
-			update.update_is_del_and_insert = true;
-			break;
-		}
-	}
-
-	if (update.update_is_del_and_insert) {
-		// the update updates a column required by an index or requires returning the updated rows,
-		// push projections for all columns
-		physical_index_set_t all_columns;
-		for (idx_t i = 0; i < storage.column_definitions.size(); i++) {
-			all_columns.insert(PhysicalIndex(i));
-		}
-		BindExtraColumns(table, get, proj, update, all_columns);
-	}
-}
-
 // This creates a LogicalProjection and moves 'root' into it as a child
 // unless there are no expressions to project, in which case it just returns 'root'
 unique_ptr<LogicalOperator> Binder::BindUpdateSet(LogicalOperator &op, unique_ptr<LogicalOperator> root,
@@ -239,7 +126,8 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 	auto proj = unique_ptr_cast<LogicalOperator, LogicalProjection>(std::move(proj_tmp));
 
 	// bind any extra columns necessary for CHECK constraints or indexes
-	BindUpdateConstraints(table, *get, *proj, *update);
+	table.BindUpdateConstraints(*get, *proj, *update);
+
 	// finally add the row id column to the projection list
 	proj->expressions.push_back(make_uniq<BoundColumnRefExpression>(
 	    LogicalType::ROW_TYPE, ColumnBinding(get->table_index, get->column_ids.size())));

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(
@@ -250,7 +250,9 @@ unique_ptr<BoundTableRef> Binder::BindBoundPivot(PivotRef &ref) {
 	auto &aggregates = result->bound_pivot.aggregates;
 	ExtractPivotAggregates(*result->child, aggregates);
 	if (aggregates.size() != ref.bound_aggregate_names.size()) {
-		throw InternalException("Pivot - aggregate count mismatch");
+		throw BinderException("Pivot aggregate count mismatch. Expected %llu aggregates but found %llu. Are all pivot "
+		                      "expressions aggregate functions?",
+		                      ref.bound_aggregate_names.size(), aggregates.size());
 	}
 
 	vector<string> child_names;

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>();
@@ -152,11 +161,12 @@ Binder::BindTableFunctionInternal(TableFunction &table_function, const string &f
 				table_function.extra_info = "(Multi-Threaded)";
 			}
 		}
+	} else {
+		throw InvalidInputException("Cannot call function \"%s\" directly - it has no bind function",
+		                            table_function.name);
 	}
 	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);
 }