duckdb 0.7.2-dev1457.0 → 0.7.2-dev1533.0

package/src/duckdb/src/optimizer/column_lifetime_analyzer.cpp

@@ -39,7 +39,7 @@ void ColumnLifetimeAnalyzer::StandardVisitOperator(LogicalOperator &op) {
 	LogicalOperatorVisitor::VisitOperatorExpressions(op);
 	if (op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
 		// visit the duplicate eliminated columns on the LHS, if any
-		auto &delim_join = (LogicalDelimJoin &)op;
+		auto &delim_join = op.Cast<LogicalDelimJoin>();
 		for (auto &expr : delim_join.duplicate_eliminated_columns) {
 			VisitExpression(&expr);
 		}
@@ -63,7 +63,7 @@ void ColumnLifetimeAnalyzer::VisitOperator(LogicalOperator &op) {
 		if (everything_referenced) {
 			break;
 		}
-		auto &comp_join = (LogicalComparisonJoin &)op;
+		auto &comp_join = op.Cast<LogicalComparisonJoin>();
 		if (comp_join.join_type == JoinType::MARK || comp_join.join_type == JoinType::SEMI ||
 		    comp_join.join_type == JoinType::ANTI) {
 			break;
@@ -116,7 +116,7 @@ void ColumnLifetimeAnalyzer::VisitOperator(LogicalOperator &op) {
 		break;
 	}
 	case LogicalOperatorType::LOGICAL_FILTER: {
-		auto &filter = (LogicalFilter &)op;
+		auto &filter = op.Cast<LogicalFilter>();
 		if (everything_referenced) {
 			break;
 		}

package/src/duckdb/src/optimizer/common_aggregate_optimizer.cpp

@@ -11,7 +11,7 @@ void CommonAggregateOptimizer::VisitOperator(LogicalOperator &op) {
 	LogicalOperatorVisitor::VisitOperator(op);
 	switch (op.type) {
 	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY:
-		ExtractCommonAggregates((LogicalAggregate &)op);
+		ExtractCommonAggregates(op.Cast<LogicalAggregate>());
 		break;
 	default:
 		break;

package/src/duckdb/src/optimizer/cse_optimizer.cpp

@@ -76,7 +76,7 @@ void CommonSubExpressionOptimizer::CountExpressions(Expression &expr, CSEReplace
 void CommonSubExpressionOptimizer::PerformCSEReplacement(unique_ptr<Expression> *expr_ptr, CSEReplacementState &state) {
 	Expression &expr = **expr_ptr;
 	if (expr.expression_class == ExpressionClass::BOUND_COLUMN_REF) {
-		auto &bound_column_ref = (BoundColumnRefExpression &)expr;
+		auto &bound_column_ref = expr.Cast<BoundColumnRefExpression>();
 		// bound column ref, check if this one has already been recorded in the expression list
 		auto column_entry = state.column_map.find(bound_column_ref.binding);
 		if (column_entry == state.column_map.end()) {

package/src/duckdb/src/optimizer/deliminator.cpp

@@ -66,7 +66,7 @@ void DeliminatorPlanUpdater::VisitOperator(LogicalOperator &op) {
 	VisitOperatorChildren(op);
 	VisitOperatorExpressions(op);
 	if (op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN && DelimGetCount(op) == 0) {
-		auto &delim_join = (LogicalDelimJoin &)op;
+		auto &delim_join = op.Cast<LogicalDelimJoin>();
 		auto decs = &delim_join.duplicate_eliminated_columns;
 		for (auto &cond : delim_join.conditions) {
 			if (!IsEqualityJoinCondition(cond)) {
@@ -74,13 +74,13 @@ void DeliminatorPlanUpdater::VisitOperator(LogicalOperator &op) {
 			}
 			auto rhs = cond.right.get();
 			while (rhs->type == ExpressionType::OPERATOR_CAST) {
-				auto &cast = (BoundCastExpression &)*rhs;
+				auto &cast = rhs->Cast<BoundCastExpression>();
 				rhs = cast.child.get();
 			}
 			if (rhs->type != ExpressionType::BOUND_COLUMN_REF) {
 				throw InternalException("Error in Deliminator: expected a bound column reference");
 			}
-			auto &colref = (BoundColumnRefExpression &)*rhs;
+			auto &colref = rhs->Cast<BoundColumnRefExpression>();
 			if (projection_map.find(colref.binding) != projection_map.end()) {
 				// value on the right is a projection of removed DelimGet
 				for (idx_t i = 0; i < decs->size(); i++) {
@@ -187,7 +187,7 @@ static bool ChildJoinTypeCanBeDeliminated(JoinType &join_type) {
 bool Deliminator::RemoveCandidate(unique_ptr<LogicalOperator> *plan, unique_ptr<LogicalOperator> *candidate,
                                   DeliminatorPlanUpdater &updater) {
 	auto &proj_or_agg = **candidate;
-	auto &join = (LogicalComparisonJoin &)*proj_or_agg.children[0];
+	auto &join = proj_or_agg.children[0]->Cast<LogicalComparisonJoin>();
 	if (!ChildJoinTypeCanBeDeliminated(join.join_type)) {
 		return false;
 	}
@@ -200,7 +200,7 @@ bool Deliminator::RemoveCandidate(unique_ptr<LogicalOperator> *plan, unique_ptr<
 	if (join.children[delim_idx]->type == LogicalOperatorType::LOGICAL_FILTER) {
 		filter = (LogicalFilter *)join.children[delim_idx].get();
 	}
-	auto &delim_get = (LogicalDelimGet &)*(filter ? filter->children[0].get() : join.children[delim_idx].get());
+	auto &delim_get = (filter ? filter->children[0] : join.children[delim_idx])->Cast<LogicalDelimGet>();
 	if (join.conditions.size() != delim_get.chunk_types.size()) {
 		// joining with DelimGet adds new information
 		return false;
@@ -236,7 +236,7 @@ bool Deliminator::RemoveCandidate(unique_ptr<LogicalOperator> *plan, unique_ptr<
 			}
 		}
 	} else {
-		auto &agg = (LogicalAggregate &)proj_or_agg;
+		auto &agg = proj_or_agg.Cast<LogicalAggregate>();
 
 		// Create a vector of all exprs in the agg
 		vector<Expression *> all_agg_exprs;
@@ -345,7 +345,7 @@ bool Deliminator::RemoveInequalityCandidate(unique_ptr<LogicalOperator> *plan, u
 		}
 
 		// we can only remove inequality join with a DelimGet if the parent DelimJoin has one of these join types
-		auto &delim_join = (LogicalDelimJoin &)*dj;
+		auto &delim_join = dj->Cast<LogicalDelimJoin>();
 		if (!InequalityDelimJoinCanBeEliminated(delim_join.join_type)) {
 			continue;
 		}
@@ -359,8 +359,8 @@ bool Deliminator::RemoveInequalityCandidate(unique_ptr<LogicalOperator> *plan, u
 
 	// we found the parent delim join, and we may be able to remove the child DelimGet join
 	// but we need to make sure that their conditions refer to exactly the same columns
-	auto &parent_delim_join = (LogicalDelimJoin &)*parent;
-	auto &join = (LogicalComparisonJoin &)*proj_or_agg.children[0];
+	auto &parent_delim_join = parent->Cast<LogicalDelimJoin>();
+	auto &join = proj_or_agg.children[0]->Cast<LogicalComparisonJoin>();
 	if (parent_delim_join.conditions.size() != join.conditions.size()) {
 		// different number of conditions, can't replace
 		return false;
@@ -376,7 +376,7 @@ bool Deliminator::RemoveInequalityCandidate(unique_ptr<LogicalOperator> *plan, u
 			// can only deal with colrefs
 			return false;
 		}
-		auto &parent_colref = (BoundColumnRefExpression &)*parent_expr;
+		auto &parent_colref = parent_expr->Cast<BoundColumnRefExpression>();
 		auto it = updater.reverse_proj_or_agg_map.find(parent_colref.binding);
 		if (it == updater.reverse_proj_or_agg_map.end()) {
 			// refers to a column that was not in the child DelimGet join
@@ -414,7 +414,7 @@ bool Deliminator::RemoveInequalityCandidate(unique_ptr<LogicalOperator> *plan, u
 	// this time without checks because we already did them, and replace the expressions
 	for (auto &parent_cond : parent_delim_join.conditions) {
 		auto &parent_expr = parent_delim_get_side == 0 ? parent_cond.left : parent_cond.right;
-		auto &parent_colref = (BoundColumnRefExpression &)*parent_expr;
+		auto &parent_colref = parent_expr->Cast<BoundColumnRefExpression>();
 		auto it = updater.reverse_proj_or_agg_map.find(parent_colref.binding);
 		auto child_expr = it->second;
 		for (auto &child_cond : join.conditions) {

package/src/duckdb/src/optimizer/expression_heuristics.cpp

@@ -152,47 +152,47 @@ idx_t ExpressionHeuristics::ExpressionCost(PhysicalType return_type, idx_t multi
 idx_t ExpressionHeuristics::Cost(Expression &expr) {
 	switch (expr.expression_class) {
 	case ExpressionClass::BOUND_CASE: {
-		auto &case_expr = (BoundCaseExpression &)expr;
+		auto &case_expr = expr.Cast<BoundCaseExpression>();
 		return ExpressionCost(case_expr);
 	}
 	case ExpressionClass::BOUND_BETWEEN: {
-		auto &between_expr = (BoundBetweenExpression &)expr;
+		auto &between_expr = expr.Cast<BoundBetweenExpression>();
 		return ExpressionCost(between_expr);
 	}
 	case ExpressionClass::BOUND_CAST: {
-		auto &cast_expr = (BoundCastExpression &)expr;
+		auto &cast_expr = expr.Cast<BoundCastExpression>();
 		return ExpressionCost(cast_expr);
 	}
 	case ExpressionClass::BOUND_COMPARISON: {
-		auto &comp_expr = (BoundComparisonExpression &)expr;
+		auto &comp_expr = expr.Cast<BoundComparisonExpression>();
 		return ExpressionCost(comp_expr);
 	}
 	case ExpressionClass::BOUND_CONJUNCTION: {
-		auto &conj_expr = (BoundConjunctionExpression &)expr;
+		auto &conj_expr = expr.Cast<BoundConjunctionExpression>();
 		return ExpressionCost(conj_expr);
 	}
 	case ExpressionClass::BOUND_FUNCTION: {
-		auto &func_expr = (BoundFunctionExpression &)expr;
+		auto &func_expr = expr.Cast<BoundFunctionExpression>();
 		return ExpressionCost(func_expr);
 	}
 	case ExpressionClass::BOUND_OPERATOR: {
-		auto &op_expr = (BoundOperatorExpression &)expr;
+		auto &op_expr = expr.Cast<BoundOperatorExpression>();
 		return ExpressionCost(op_expr, expr.type);
 	}
 	case ExpressionClass::BOUND_COLUMN_REF: {
-		auto &col_expr = (BoundColumnRefExpression &)expr;
+		auto &col_expr = expr.Cast<BoundColumnRefExpression>();
 		return ExpressionCost(col_expr.return_type.InternalType(), 8);
 	}
 	case ExpressionClass::BOUND_CONSTANT: {
-		auto &const_expr = (BoundConstantExpression &)expr;
+		auto &const_expr = expr.Cast<BoundConstantExpression>();
 		return ExpressionCost(const_expr.return_type.InternalType(), 1);
 	}
 	case ExpressionClass::BOUND_PARAMETER: {
-		auto &const_expr = (BoundParameterExpression &)expr;
+		auto &const_expr = expr.Cast<BoundParameterExpression>();
 		return ExpressionCost(const_expr.return_type.InternalType(), 1);
 	}
 	case ExpressionClass::BOUND_REF: {
-		auto &col_expr = (BoundColumnRefExpression &)expr;
+		auto &col_expr = expr.Cast<BoundColumnRefExpression>();
 		return ExpressionCost(col_expr.return_type.InternalType(), 8);
 	}
 	default: {

package/src/duckdb/src/optimizer/expression_rewriter.cpp

@@ -74,7 +74,7 @@ void ExpressionRewriter::VisitOperator(LogicalOperator &op) {
 
 	// if it is a LogicalFilter, we split up filter conjunctions again
 	if (op.type == LogicalOperatorType::LOGICAL_FILTER) {
-		auto &filter = (LogicalFilter &)op;
+		auto &filter = op.Cast<LogicalFilter>();
 		filter.SplitPredicates();
 	}
 }

package/src/duckdb/src/optimizer/filter_combiner.cpp

@@ -251,7 +251,7 @@ bool FilterCombiner::HasFilters() {
 // { 	unordered_map<idx_t, std::pair<Value *, Value *>> checks; 	switch (filter->type) { 	case
 // ExpressionType::CONJUNCTION_OR: {
 // 		//! For a filter to
-// 		auto &or_exp = (BoundConjunctionExpression &)*filter;
+// 		auto &or_exp = filter->Cast<BoundConjunctionExpression>();
 // 		checks = FindZonemapChecks(column_ids, not_constants, or_exp.children[0].get());
 // 		for (size_t i = 1; i < or_exp.children.size(); ++i) {
 // 			auto child_check = FindZonemapChecks(column_ids, not_constants, or_exp.children[i].get());
@@ -260,7 +260,7 @@ bool FilterCombiner::HasFilters() {
 // 		return checks;
 // 	}
 // 	case ExpressionType::CONJUNCTION_AND: {
-// 		auto &and_exp = (BoundConjunctionExpression &)*filter;
+// 		auto &and_exp = filter->Cast<BoundConjunctionExpression>();
 // 		checks = FindZonemapChecks(column_ids, not_constants, and_exp.children[0].get());
 // 		for (size_t i = 1; i < and_exp.children.size(); ++i) {
 // 			auto child_check = FindZonemapChecks(column_ids, not_constants, and_exp.children[i].get());
@@ -269,17 +269,17 @@ bool FilterCombiner::HasFilters() {
 // 		return checks;
 // 	}
 // 	case ExpressionType::COMPARE_IN: {
-// 		auto &comp_in_exp = (BoundOperatorExpression &)*filter;
+// 		auto &comp_in_exp = filter->Cast<BoundOperatorExpression>();
 // 		if (comp_in_exp.children[0]->type == ExpressionType::BOUND_COLUMN_REF) {
 // 			Value *min = nullptr, *max = nullptr;
-// 			auto &column_ref = (BoundColumnRefExpression &)*comp_in_exp.children[0].get();
+// 			auto &column_ref = comp_in_exp.children[0]->Cast<BoundColumnRefExpression>();
 // 			for (size_t i {1}; i < comp_in_exp.children.size(); i++) {
 // 				if (comp_in_exp.children[i]->type != ExpressionType::VALUE_CONSTANT) {
 // 					//! This indicates the column has a comparison that is not with a constant
 // 					not_constants.insert(column_ids[column_ref.binding.column_index]);
 // 					break;
 // 				} else {
-// 					auto &const_value_expr = (BoundConstantExpression &)*comp_in_exp.children[i].get();
+// 					auto &const_value_expr = comp_in_exp.children[i]->Cast<BoundConstantExpression>();
 // 					if (const_value_expr.value.IsNull()) {
 // 						return checks;
 // 					}
@@ -301,18 +301,18 @@ bool FilterCombiner::HasFilters() {
 // 		return checks;
 // 	}
 // 	case ExpressionType::COMPARE_EQUAL: {
-// 		auto &comp_exp = (BoundComparisonExpression &)*filter;
+// 		auto &comp_exp = filter->Cast<BoundComparisonExpression>();
 // 		if ((comp_exp.left->expression_class == ExpressionClass::BOUND_COLUMN_REF &&
 // 		     comp_exp.right->expression_class == ExpressionClass::BOUND_CONSTANT)) {
-// 			auto &column_ref = (BoundColumnRefExpression &)*comp_exp.left;
-// 			auto &constant_value_expr = (BoundConstantExpression &)*comp_exp.right;
+// 			auto &column_ref = comp_exp.left->Cast<BoundColumnRefExpression>();
+// 			auto &constant_value_expr = comp_exp.right->Cast<BoundConstantExpression>();
 // 			checks[column_ids[column_ref.binding.column_index]] = {&constant_value_expr.value,
 // 			                                                       &constant_value_expr.value};
 // 		}
 // 		if ((comp_exp.left->expression_class == ExpressionClass::BOUND_CONSTANT &&
 // 		     comp_exp.right->expression_class == ExpressionClass::BOUND_COLUMN_REF)) {
-// 			auto &column_ref = (BoundColumnRefExpression &)*comp_exp.right;
-// 			auto &constant_value_expr = (BoundConstantExpression &)*comp_exp.left;
+// 			auto &column_ref = comp_exp.right->Cast<BoundColumnRefExpression>();
+// 			auto &constant_value_expr = comp_exp.left->Cast<BoundConstantExpression>();
 // 			checks[column_ids[column_ref.binding.column_index]] = {&constant_value_expr.value,
 // 			                                                       &constant_value_expr.value};
 // 		}
@@ -320,34 +320,34 @@ bool FilterCombiner::HasFilters() {
 // 	}
 // 	case ExpressionType::COMPARE_LESSTHAN:
 // 	case ExpressionType::COMPARE_LESSTHANOREQUALTO: {
-// 		auto &comp_exp = (BoundComparisonExpression &)*filter;
+// 		auto &comp_exp = filter->Cast<BoundComparisonExpression>();
 // 		if ((comp_exp.left->expression_class == ExpressionClass::BOUND_COLUMN_REF &&
 // 		     comp_exp.right->expression_class == ExpressionClass::BOUND_CONSTANT)) {
-// 			auto &column_ref = (BoundColumnRefExpression &)*comp_exp.left;
-// 			auto &constant_value_expr = (BoundConstantExpression &)*comp_exp.right;
+// 			auto &column_ref = comp_exp.left->Cast<BoundColumnRefExpression>();
+// 			auto &constant_value_expr = comp_exp.right->Cast<BoundConstantExpression>();
 // 			checks[column_ids[column_ref.binding.column_index]] = {nullptr, &constant_value_expr.value};
 // 		}
 // 		if ((comp_exp.left->expression_class == ExpressionClass::BOUND_CONSTANT &&
 // 		     comp_exp.right->expression_class == ExpressionClass::BOUND_COLUMN_REF)) {
-// 			auto &column_ref = (BoundColumnRefExpression &)*comp_exp.right;
-// 			auto &constant_value_expr = (BoundConstantExpression &)*comp_exp.left;
+// 			auto &column_ref = comp_exp.right->Cast<BoundColumnRefExpression>();
+// 			auto &constant_value_expr = comp_exp.left->Cast<BoundConstantExpression>();
 // 			checks[column_ids[column_ref.binding.column_index]] = {&constant_value_expr.value, nullptr};
 // 		}
 // 		return checks;
 // 	}
 // 	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
 // 	case ExpressionType::COMPARE_GREATERTHAN: {
-// 		auto &comp_exp = (BoundComparisonExpression &)*filter;
+// 		auto &comp_exp = filter->Cast<BoundComparisonExpression>();
 // 		if ((comp_exp.left->expression_class == ExpressionClass::BOUND_COLUMN_REF &&
 // 		     comp_exp.right->expression_class == ExpressionClass::BOUND_CONSTANT)) {
-// 			auto &column_ref = (BoundColumnRefExpression &)*comp_exp.left;
-// 			auto &constant_value_expr = (BoundConstantExpression &)*comp_exp.right;
+// 			auto &column_ref = comp_exp.left->Cast<BoundColumnRefExpression>();
+// 			auto &constant_value_expr = comp_exp.right->Cast<BoundConstantExpression>();
 // 			checks[column_ids[column_ref.binding.column_index]] = {&constant_value_expr.value, nullptr};
 // 		}
 // 		if ((comp_exp.left->expression_class == ExpressionClass::BOUND_CONSTANT &&
 // 		     comp_exp.right->expression_class == ExpressionClass::BOUND_COLUMN_REF)) {
-// 			auto &column_ref = (BoundColumnRefExpression &)*comp_exp.right;
-// 			auto &constant_value_expr = (BoundConstantExpression &)*comp_exp.left;
+// 			auto &column_ref = comp_exp.right->Cast<BoundColumnRefExpression>();
+// 			auto &constant_value_expr = comp_exp.left->Cast<BoundConstantExpression>();
 // 			checks[column_ids[column_ref.binding.column_index]] = {nullptr, &constant_value_expr.value};
 // 		}
 // 		return checks;
@@ -435,13 +435,13 @@ TableFilterSet FilterCombiner::GenerateTableScanFilters(vector<idx_t> &column_id
 	for (idx_t rem_fil_idx = 0; rem_fil_idx < remaining_filters.size(); rem_fil_idx++) {
 		auto &remaining_filter = remaining_filters[rem_fil_idx];
 		if (remaining_filter->expression_class == ExpressionClass::BOUND_FUNCTION) {
-			auto &func = (BoundFunctionExpression &)*remaining_filter;
+			auto &func = remaining_filter->Cast<BoundFunctionExpression>();
 			if (func.function.name == "prefix" &&
 			    func.children[0]->expression_class == ExpressionClass::BOUND_COLUMN_REF &&
 			    func.children[1]->type == ExpressionType::VALUE_CONSTANT) {
 				//! This is a like function.
-				auto &column_ref = (BoundColumnRefExpression &)*func.children[0].get();
-				auto &constant_value_expr = (BoundConstantExpression &)*func.children[1].get();
+				auto &column_ref = func.children[0]->Cast<BoundColumnRefExpression>();
+				auto &constant_value_expr = func.children[1]->Cast<BoundConstantExpression>();
 				auto like_string = StringValue::Get(constant_value_expr.value);
 				if (like_string.empty()) {
 					continue;
@@ -459,8 +459,8 @@ TableFilterSet FilterCombiner::GenerateTableScanFilters(vector<idx_t> &column_id
 			if (func.function.name == "~~" && func.children[0]->expression_class == ExpressionClass::BOUND_COLUMN_REF &&
 			    func.children[1]->type == ExpressionType::VALUE_CONSTANT) {
 				//! This is a like function.
-				auto &column_ref = (BoundColumnRefExpression &)*func.children[0].get();
-				auto &constant_value_expr = (BoundConstantExpression &)*func.children[1].get();
+				auto &column_ref = func.children[0]->Cast<BoundColumnRefExpression>();
+				auto &constant_value_expr = func.children[1]->Cast<BoundConstantExpression>();
 				auto &like_string = StringValue::Get(constant_value_expr.value);
 				if (like_string[0] == '%' || like_string[0] == '_') {
 					//! We have no prefix so nothing to pushdown
@@ -493,13 +493,13 @@ TableFilterSet FilterCombiner::GenerateTableScanFilters(vector<idx_t> &column_id
 				}
 			}
 		} else if (remaining_filter->type == ExpressionType::COMPARE_IN) {
-			auto &func = (BoundOperatorExpression &)*remaining_filter;
+			auto &func = remaining_filter->Cast<BoundOperatorExpression>();
 			vector<hugeint_t> in_values;
 			D_ASSERT(func.children.size() > 1);
 			if (func.children[0]->expression_class != ExpressionClass::BOUND_COLUMN_REF) {
 				continue;
 			}
-			auto &column_ref = (BoundColumnRefExpression &)*func.children[0].get();
+			auto &column_ref = func.children[0]->Cast<BoundColumnRefExpression>();
 			auto column_index = column_ids[column_ref.binding.column_index];
 			if (column_index == COLUMN_IDENTIFIER_ROW_ID) {
 				break;
@@ -514,7 +514,7 @@ TableFilterSet FilterCombiner::GenerateTableScanFilters(vector<idx_t> &column_id
 			if (!children_constant) {
 				continue;
 			}
-			auto &fst_const_value_expr = (BoundConstantExpression &)*func.children[1].get();
+			auto &fst_const_value_expr = func.children[1]->Cast<BoundConstantExpression>();
 			auto &type = fst_const_value_expr.value.type();
 
 			//! Check if values are consecutive, if yes transform them to >= <= (only for integers)
@@ -525,7 +525,7 @@ TableFilterSet FilterCombiner::GenerateTableScanFilters(vector<idx_t> &column_id
 
 			bool can_simplify_in_clause = true;
 			for (idx_t i = 1; i < func.children.size(); i++) {
-				auto &const_value_expr = (BoundConstantExpression &)*func.children[i].get();
+				auto &const_value_expr = func.children[i]->Cast<BoundConstantExpression>();
 				if (const_value_expr.value.IsNull()) {
 					can_simplify_in_clause = false;
 					break;
@@ -573,7 +573,7 @@ static bool IsLessThan(ExpressionType type) {
 }
 
 FilterResult FilterCombiner::AddBoundComparisonFilter(Expression *expr) {
-	auto &comparison = (BoundComparisonExpression &)*expr;
+	auto &comparison = expr->Cast<BoundComparisonExpression>();
 	if (comparison.type != ExpressionType::COMPARE_LESSTHAN &&
 	    comparison.type != ExpressionType::COMPARE_LESSTHANOREQUALTO &&
 	    comparison.type != ExpressionType::COMPARE_GREATERTHAN &&
@@ -615,7 +615,8 @@ FilterResult FilterCombiner::AddBoundComparisonFilter(Expression *expr) {
 		auto transitive_filter = FindTransitiveFilter(non_scalar);
 		if (transitive_filter != nullptr) {
 			// try to add transitive filters
-			if (AddTransitiveFilters((BoundComparisonExpression &)*transitive_filter) == FilterResult::UNSUPPORTED) {
+			if (AddTransitiveFilters(transitive_filter->Cast<BoundComparisonExpression>()) ==
+			    FilterResult::UNSUPPORTED) {
 				// in case of unsuccessful re-add filter into remaining ones
 				remaining_filters.push_back(std::move(transitive_filter));
 			}
@@ -691,7 +692,7 @@ FilterResult FilterCombiner::AddFilter(Expression *expr) {
 	}
 	D_ASSERT(!expr->IsFoldable());
 	if (expr->GetExpressionClass() == ExpressionClass::BOUND_BETWEEN) {
-		auto &comparison = (BoundBetweenExpression &)*expr;
+		auto &comparison = expr->Cast<BoundBetweenExpression>();
 		//! check if one of the sides is a scalar value
 		bool lower_is_scalar = comparison.lower->IsFoldable();
 		bool upper_is_scalar = comparison.upper->IsFoldable();
@@ -787,12 +788,12 @@ FilterResult FilterCombiner::AddTransitiveFilters(BoundComparisonExpression &com
 	Expression *right_node = GetNode(comparison.right.get());
 	// In case with filters like CAST(i) = j and i = 5 we replace the COLUMN_REF i with the constant 5
 	if (right_node->type == ExpressionType::OPERATOR_CAST) {
-		auto &bound_cast_expr = (BoundCastExpression &)*right_node;
+		auto &bound_cast_expr = right_node->Cast<BoundCastExpression>();
 		if (bound_cast_expr.child->type == ExpressionType::BOUND_COLUMN_REF) {
-			auto &col_ref = (BoundColumnRefExpression &)*bound_cast_expr.child;
+			auto &col_ref = bound_cast_expr.child->Cast<BoundColumnRefExpression>();
 			for (auto &stored_exp : stored_expressions) {
 				if (stored_exp.first->type == ExpressionType::BOUND_COLUMN_REF) {
-					auto &st_col_ref = (BoundColumnRefExpression &)*stored_exp.second;
+					auto &st_col_ref = stored_exp.second->Cast<BoundColumnRefExpression>();
 					if (st_col_ref.binding == col_ref.binding &&
 					    bound_cast_expr.return_type == stored_exp.second->return_type) {
 						bound_cast_expr.child = stored_exp.second->Copy();
@@ -876,7 +877,8 @@ FilterResult FilterCombiner::AddTransitiveFilters(BoundComparisonExpression &com
 		auto transitive_filter = FindTransitiveFilter(comparison.left.get());
 		if (transitive_filter != nullptr) {
 			// try to add transitive filters
-			if (AddTransitiveFilters((BoundComparisonExpression &)*transitive_filter) == FilterResult::UNSUPPORTED) {
+			if (AddTransitiveFilters(transitive_filter->Cast<BoundComparisonExpression>()) ==
+			    FilterResult::UNSUPPORTED) {
 				// in case of unsuccessful re-add filter into remaining ones
 				remaining_filters.push_back(std::move(transitive_filter));
 			}
@@ -897,8 +899,8 @@ unique_ptr<Expression> FilterCombiner::FindTransitiveFilter(Expression *expr) {
 	if (expr->type == ExpressionType::BOUND_COLUMN_REF) {
 		for (idx_t i = 0; i < remaining_filters.size(); i++) {
 			if (remaining_filters[i]->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON) {
-				auto comparison = (BoundComparisonExpression *)remaining_filters[i].get();
-				if (expr->Equals(comparison->right.get()) && comparison->type != ExpressionType::COMPARE_NOTEQUAL) {
+				auto &comparison = remaining_filters[i]->Cast<BoundComparisonExpression>();
+				if (expr->Equals(comparison.right.get()) && comparison.type != ExpressionType::COMPARE_NOTEQUAL) {
 					auto filter = std::move(remaining_filters[i]);
 					remaining_filters.erase(remaining_filters.begin() + i);
 					return filter;

package/src/duckdb/src/optimizer/filter_pullup.cpp

@@ -34,7 +34,7 @@ unique_ptr<LogicalOperator> FilterPullup::PullupJoin(unique_ptr<LogicalOperator>
 	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
 	         op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN || op->type == LogicalOperatorType::LOGICAL_ANY_JOIN ||
 	         op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
-	auto &join = (LogicalJoin &)*op;
+	auto &join = op->Cast<LogicalJoin>();
 
 	switch (join.join_type) {
 	case JoinType::INNER:
@@ -51,7 +51,7 @@ unique_ptr<LogicalOperator> FilterPullup::PullupJoin(unique_ptr<LogicalOperator>
 }
 
 unique_ptr<LogicalOperator> FilterPullup::PullupInnerJoin(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(((LogicalJoin &)*op).join_type == JoinType::INNER);
+	D_ASSERT(op->Cast<LogicalJoin>().join_type == JoinType::INNER);
 	if (op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
 		return op;
 	}

package/src/duckdb/src/optimizer/filter_pushdown.cpp

@@ -51,7 +51,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownJoin(unique_ptr<LogicalOpera
 	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
 	         op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN || op->type == LogicalOperatorType::LOGICAL_ANY_JOIN ||
 	         op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
-	auto &join = (LogicalJoin &)*op;
+	auto &join = op->Cast<LogicalJoin>();
 	unordered_set<idx_t> left_bindings, right_bindings;
 	LogicalJoin::GetTableReferences(*op->children[0], left_bindings);
 	LogicalJoin::GetTableReferences(*op->children[1], right_bindings);

package/src/duckdb/src/optimizer/join_order/cardinality_estimator.cpp

@@ -17,8 +17,8 @@ static TableCatalogEntry *GetCatalogTableEntry(LogicalOperator *op) {
 		return nullptr;
 	}
 	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_GET);
-	auto get = (LogicalGet *)op;
-	TableCatalogEntry *entry = get->GetTable();
+	auto &get = op->Cast<LogicalGet>();
+	TableCatalogEntry *entry = get.GetTable();
 	return entry;
 }
 
@@ -313,19 +313,19 @@ static LogicalGet *GetLogicalGet(LogicalOperator *op, idx_t table_index = DConst
 		break;
 	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
-		LogicalComparisonJoin *join = (LogicalComparisonJoin *)op;
+		LogicalComparisonJoin &join = op->Cast<LogicalComparisonJoin>();
 		// We should never be calling GetLogicalGet without a valid table_index.
 		// We are attempting to get the catalog table for a relation (for statistics/cardinality estimation)
 		// A logical join means there is a non-reorderable relation in the join plan. This means we need
 		// to know the exact table index to return.
 		D_ASSERT(table_index != DConstants::INVALID_INDEX);
-		if (join->join_type == JoinType::MARK || join->join_type == JoinType::LEFT) {
-			auto child = join->children.at(0).get();
+		if (join.join_type == JoinType::MARK || join.join_type == JoinType::LEFT) {
+			auto child = join.children.at(0).get();
 			get = GetLogicalGet(child, table_index);
 			if (get && get->table_index == table_index) {
 				return get;
 			}
-			child = join->children.at(1).get();
+			child = join.children.at(1).get();
 			get = GetLogicalGet(child, table_index);
 			if (get && get->table_index == table_index) {
 				return get;
@@ -377,7 +377,7 @@ void CardinalityEstimator::InitCardinalityEstimatorProps(vector<NodeOp> *node_op
 		auto op = (*node_ops)[i].op;
 		join_node->SetBaseTableCardinality(op->EstimateCardinality(context));
 		if (op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
-			auto &join = (LogicalComparisonJoin &)*op;
+			auto &join = op->Cast<LogicalComparisonJoin>();
 			if (join.join_type == JoinType::LEFT) {
 				// If a base op is a Logical Comparison join it is probably a left join,
 				// so the cost of the larger table is a fine estimate.
@@ -559,7 +559,7 @@ idx_t CardinalityEstimator::InspectTableFilters(idx_t cardinality, LogicalOperat
 	for (auto &it : table_filters->filters) {
 		column_statistics = nullptr;
 		if (get->bind_data && get->function.name.compare("seq_scan") == 0) {
-			auto &table_scan_bind_data = (TableScanBindData &)*get->bind_data;
+			auto &table_scan_bind_data = get->bind_data->Cast<TableScanBindData>();
 			column_statistics = get->function.statistics(context, &table_scan_bind_data, it.first);
 		}
 		if (it.second->filter_type == TableFilterType::CONJUNCTION_AND) {