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

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

@@ -36,7 +36,7 @@ static bool Disjoint(unordered_set<T> &a, unordered_set<T> &b) {
 //! Extract the set of relations referred to inside an expression
 bool JoinOrderOptimizer::ExtractBindings(Expression &expression, unordered_set<idx_t> &bindings) {
 	if (expression.type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &colref = (BoundColumnRefExpression &)expression;
+		auto &colref = expression.Cast<BoundColumnRefExpression>();
 		D_ASSERT(colref.depth == 0);
 		D_ASSERT(colref.binding.table_index != DConstants::INVALID_INDEX);
 		// map the base table index to the relation index used by the JoinOrderOptimizer
@@ -66,7 +66,7 @@ void JoinOrderOptimizer::GetColumnBinding(Expression &expression, ColumnBinding
 	if (expression.type == ExpressionType::BOUND_COLUMN_REF) {
 		// Here you have a filter on a single column in a table. Return a binding for the column
 		// being filtered on so the filter estimator knows what HLL count to pull
-		auto &colref = (BoundColumnRefExpression &)expression;
+		auto &colref = expression.Cast<BoundColumnRefExpression>();
 		D_ASSERT(colref.depth == 0);
 		D_ASSERT(colref.binding.table_index != DConstants::INVALID_INDEX);
 		// map the base table index to the relation index used by the JoinOrderOptimizer
@@ -88,8 +88,8 @@ static unique_ptr<LogicalOperator> PushFilter(unique_ptr<LogicalOperator> node,
 	}
 	// push the filter into the LogicalFilter
 	D_ASSERT(node->type == LogicalOperatorType::LOGICAL_FILTER);
-	auto filter = (LogicalFilter *)node.get();
-	filter->expressions.push_back(std::move(expr));
+	auto &filter = node->Cast<LogicalFilter>();
+	filter.expressions.push_back(std::move(expr));
 	return node;
 }
 
@@ -120,7 +120,7 @@ bool JoinOrderOptimizer::ExtractJoinRelations(LogicalOperator &input_op, vector<
 	}
 
 	if (op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
-		auto &join = (LogicalComparisonJoin &)*op;
+		auto &join = op->Cast<LogicalComparisonJoin>();
 		if (join.join_type == JoinType::INNER) {
 			// extract join conditions from inner join
 			filter_operators.push_back(op);
@@ -195,35 +195,35 @@ bool JoinOrderOptimizer::ExtractJoinRelations(LogicalOperator &input_op, vector<
 	}
 	case LogicalOperatorType::LOGICAL_GET: {
 		// base table scan, add to set of relations
-		auto get = (LogicalGet *)op;
+		auto &get = op->Cast<LogicalGet>();
 		auto relation = make_uniq<SingleJoinRelation>(&input_op, parent);
 		idx_t relation_id = relations.size();
 		//! make sure the optimizer has knowledge of the exact column bindings as well.
-		auto table_index = get->table_index;
+		auto table_index = get.table_index;
 		relation_mapping[table_index] = relation_id;
-		cardinality_estimator.AddRelationColumnMapping(get, relation_id);
+		cardinality_estimator.AddRelationColumnMapping(&get, relation_id);
 		relations.push_back(std::move(relation));
 		return true;
 	}
 	case LogicalOperatorType::LOGICAL_EXPRESSION_GET: {
 		// base table scan, add to set of relations
-		auto get = (LogicalExpressionGet *)op;
+		auto &get = op->Cast<LogicalExpressionGet>();
 		auto relation = make_uniq<SingleJoinRelation>(&input_op, parent);
 		//! make sure the optimizer has knowledge of the exact column bindings as well.
-		relation_mapping[get->table_index] = relations.size();
+		relation_mapping[get.table_index] = relations.size();
 		relations.push_back(std::move(relation));
 		return true;
 	}
 	case LogicalOperatorType::LOGICAL_DUMMY_SCAN: {
 		// table function call, add to set of relations
-		auto dummy_scan = (LogicalDummyScan *)op;
+		auto &dummy_scan = op->Cast<LogicalDummyScan>();
 		auto relation = make_uniq<SingleJoinRelation>(&input_op, parent);
-		relation_mapping[dummy_scan->table_index] = relations.size();
+		relation_mapping[dummy_scan.table_index] = relations.size();
 		relations.push_back(std::move(relation));
 		return true;
 	}
 	case LogicalOperatorType::LOGICAL_PROJECTION: {
-		auto proj = (LogicalProjection *)op;
+		auto &proj = op->Cast<LogicalProjection>();
 		// we run the join order optimizer within the subquery as well
 		JoinOrderOptimizer optimizer(context);
 		op->children[0] = optimizer.Optimize(std::move(op->children[0]));
@@ -236,10 +236,10 @@ bool JoinOrderOptimizer::ExtractJoinRelations(LogicalOperator &input_op, vector<
 		optimizer.cardinality_estimator.CopyRelationMap(child_binding_maps.at(0));
 		// This logical projection may sit on top of a logical comparison join that has been pushed down
 		// we want to copy the binding info of both tables
-		relation_mapping[proj->table_index] = relation_id;
+		relation_mapping[proj.table_index] = relation_id;
 		for (auto &binding_info : child_binding_maps.at(0)) {
 			cardinality_estimator.AddRelationToColumnMapping(
-			    ColumnBinding(proj->table_index, binding_info.first.column_index), binding_info.second);
+			    ColumnBinding(proj.table_index, binding_info.first.column_index), binding_info.second);
 			cardinality_estimator.AddColumnToRelationMap(binding_info.second.table_index,
 			                                             binding_info.second.column_index);
 		}
@@ -762,7 +762,7 @@ JoinOrderOptimizer::GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted
 				          JoinRelationSet::IsSubset(right.first, f->left_set)));
 				JoinCondition cond;
 				D_ASSERT(condition->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON);
-				auto &comparison = (BoundComparisonExpression &)*condition;
+				auto &comparison = condition->Cast<BoundComparisonExpression>();
 				// we need to figure out which side is which by looking at the relations available to us
 				bool invert = !JoinRelationSet::IsSubset(left.first, f->left_set);
 				cond.left = !invert ? std::move(comparison.left) : std::move(comparison.right);
@@ -841,7 +841,7 @@ JoinOrderOptimizer::GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted
 				// create the join condition
 				JoinCondition cond;
 				D_ASSERT(filter->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON);
-				auto &comparison = (BoundComparisonExpression &)*filter;
+				auto &comparison = filter->Cast<BoundComparisonExpression>();
 				// we need to figure out which side is which by looking at the relations available to us
 				cond.left = !invert ? std::move(comparison.left) : std::move(comparison.right);
 				cond.right = !invert ? std::move(comparison.right) : std::move(comparison.left);
@@ -870,7 +870,7 @@ JoinOrderOptimizer::GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted
 				} else {
 					D_ASSERT(node->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
 					         node->type == LogicalOperatorType::LOGICAL_ASOF_JOIN);
-					auto &comp_join = (LogicalComparisonJoin &)*node;
+					auto &comp_join = node->Cast<LogicalComparisonJoin>();
 					comp_join.conditions.push_back(std::move(cond));
 				}
 			}
@@ -949,7 +949,7 @@ unique_ptr<LogicalOperator> JoinOrderOptimizer::Optimize(unique_ptr<LogicalOpera
 	for (auto &f_op : filter_operators) {
 		if (f_op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
 		    f_op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN) {
-			auto &join = (LogicalComparisonJoin &)*f_op;
+			auto &join = f_op->Cast<LogicalComparisonJoin>();
 			D_ASSERT(join.join_type == JoinType::INNER);
 			D_ASSERT(join.expressions.empty());
 			for (auto &cond : join.conditions) {
@@ -984,13 +984,13 @@ unique_ptr<LogicalOperator> JoinOrderOptimizer::Optimize(unique_ptr<LogicalOpera
 		filter_info->filter_index = i;
 		// now check if it can be used as a join predicate
 		if (filter->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON) {
-			auto comparison = (BoundComparisonExpression *)filter.get();
+			auto &comparison = filter->Cast<BoundComparisonExpression>();
 			// extract the bindings that are required for the left and right side of the comparison
 			unordered_set<idx_t> left_bindings, right_bindings;
-			ExtractBindings(*comparison->left, left_bindings);
-			ExtractBindings(*comparison->right, right_bindings);
-			GetColumnBinding(*comparison->left, filter_info->left_binding);
-			GetColumnBinding(*comparison->right, filter_info->right_binding);
+			ExtractBindings(*comparison.left, left_bindings);
+			ExtractBindings(*comparison.right, right_bindings);
+			GetColumnBinding(*comparison.left, filter_info->left_binding);
+			GetColumnBinding(*comparison.right, filter_info->right_binding);
 			if (!left_bindings.empty() && !right_bindings.empty()) {
 				// both the left and the right side have bindings
 				// first create the relation sets, if they do not exist

package/src/duckdb/src/optimizer/matcher/expression_matcher.cpp

@@ -37,8 +37,8 @@ bool ComparisonExpressionMatcher::Match(Expression *expr_p, vector<Expression *>
 	if (!ExpressionMatcher::Match(expr_p, bindings)) {
 		return false;
 	}
-	auto expr = (BoundComparisonExpression *)expr_p;
-	vector<Expression *> expressions = {expr->left.get(), expr->right.get()};
+	auto &expr = expr_p->Cast<BoundComparisonExpression>();
+	vector<Expression *> expressions = {expr.left.get(), expr.right.get()};
 	return SetMatcher::Match(matchers, expressions, bindings, policy);
 }
 
@@ -49,27 +49,27 @@ bool CastExpressionMatcher::Match(Expression *expr_p, vector<Expression *> &bind
 	if (!matcher) {
 		return true;
 	}
-	auto expr = (BoundCastExpression *)expr_p;
-	return matcher->Match(expr->child.get(), bindings);
+	auto &expr = expr_p->Cast<BoundCastExpression>();
+	return matcher->Match(expr.child.get(), bindings);
 }
 
 bool InClauseExpressionMatcher::Match(Expression *expr_p, vector<Expression *> &bindings) {
 	if (!ExpressionMatcher::Match(expr_p, bindings)) {
 		return false;
 	}
-	auto expr = (BoundOperatorExpression *)expr_p;
-	if (expr->type != ExpressionType::COMPARE_IN || expr->type == ExpressionType::COMPARE_NOT_IN) {
+	auto &expr = expr_p->Cast<BoundOperatorExpression>();
+	if (expr.type != ExpressionType::COMPARE_IN || expr.type == ExpressionType::COMPARE_NOT_IN) {
 		return false;
 	}
-	return SetMatcher::Match(matchers, expr->children, bindings, policy);
+	return SetMatcher::Match(matchers, expr.children, bindings, policy);
 }
 
 bool ConjunctionExpressionMatcher::Match(Expression *expr_p, vector<Expression *> &bindings) {
 	if (!ExpressionMatcher::Match(expr_p, bindings)) {
 		return false;
 	}
-	auto expr = (BoundConjunctionExpression *)expr_p;
-	if (!SetMatcher::Match(matchers, expr->children, bindings, policy)) {
+	auto &expr = expr_p->Cast<BoundConjunctionExpression>();
+	if (!SetMatcher::Match(matchers, expr.children, bindings, policy)) {
 		return false;
 	}
 	return true;
@@ -79,11 +79,11 @@ bool FunctionExpressionMatcher::Match(Expression *expr_p, vector<Expression *> &
 	if (!ExpressionMatcher::Match(expr_p, bindings)) {
 		return false;
 	}
-	auto expr = (BoundFunctionExpression *)expr_p;
-	if (!FunctionMatcher::Match(function, expr->function.name)) {
+	auto &expr = expr_p->Cast<BoundFunctionExpression>();
+	if (!FunctionMatcher::Match(function, expr.function.name)) {
 		return false;
 	}
-	if (!SetMatcher::Match(matchers, expr->children, bindings, policy)) {
+	if (!SetMatcher::Match(matchers, expr.children, bindings, policy)) {
 		return false;
 	}
 	return true;

package/src/duckdb/src/optimizer/pullup/pullup_filter.cpp

@@ -9,7 +9,7 @@ namespace duckdb {
 unique_ptr<LogicalOperator> FilterPullup::PullupFilter(unique_ptr<LogicalOperator> op) {
 	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_FILTER);
 
-	auto &filter = (LogicalFilter &)*op;
+	auto &filter = op->Cast<LogicalFilter>();
 	if (can_pullup && filter.projection_map.empty()) {
 		unique_ptr<LogicalOperator> child = std::move(op->children[0]);
 		child = Rewrite(std::move(child));

package/src/duckdb/src/optimizer/pullup/pullup_projection.cpp

@@ -21,7 +21,7 @@ static void ReplaceExpressionBinding(vector<unique_ptr<Expression>> &proj_expres
                                      idx_t proj_table_idx) {
 	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
 		bool found_proj_col = false;
-		BoundColumnRefExpression &colref = (BoundColumnRefExpression &)expr;
+		BoundColumnRefExpression &colref = expr.Cast<BoundColumnRefExpression>();
 		// find the corresponding column index in the projection expressions
 		for (idx_t proj_idx = 0; proj_idx < proj_expressions.size(); proj_idx++) {
 			auto proj_expr = proj_expressions[proj_idx].get();
@@ -79,7 +79,7 @@ unique_ptr<LogicalOperator> FilterPullup::PullupProjection(unique_ptr<LogicalOpe
 	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_PROJECTION);
 	op->children[0] = Rewrite(std::move(op->children[0]));
 	if (!filters_expr_pullup.empty()) {
-		auto &proj = (LogicalProjection &)*op;
+		auto &proj = op->Cast<LogicalProjection>();
 		// INTERSECT, EXCEPT, and DISTINCT
 		if (!can_add_column) {
 			// special treatment for operators that cannot add columns, e.g., INTERSECT, EXCEPT, and DISTINCT

package/src/duckdb/src/optimizer/pullup/pullup_set_operation.cpp

@@ -7,7 +7,7 @@ namespace duckdb {
 
 static void ReplaceFilterTableIndex(Expression &expr, LogicalSetOperation &setop) {
 	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &colref = (BoundColumnRefExpression &)expr;
+		auto &colref = expr.Cast<BoundColumnRefExpression>();
 		D_ASSERT(colref.depth == 0);
 
 		colref.binding.table_index = setop.table_index;
@@ -27,8 +27,8 @@ unique_ptr<LogicalOperator> FilterPullup::PullupSetOperation(unique_ptr<LogicalO
 		op = PullupFromLeft(std::move(op));
 	}
 	if (op->type == LogicalOperatorType::LOGICAL_FILTER) {
-		auto &filter = (LogicalFilter &)*op;
-		auto &setop = (LogicalSetOperation &)*filter.children[0];
+		auto &filter = op->Cast<LogicalFilter>();
+		auto &setop = filter.children[0]->Cast<LogicalSetOperation>();
 		for (idx_t i = 0; i < filter.expressions.size(); ++i) {
 			ReplaceFilterTableIndex(*filter.expressions[i], setop);
 		}

package/src/duckdb/src/optimizer/pushdown/pushdown_aggregate.cpp

@@ -11,7 +11,7 @@ using Filter = FilterPushdown::Filter;
 
 static void ExtractFilterBindings(Expression &expr, vector<ColumnBinding> &bindings) {
 	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &colref = (BoundColumnRefExpression &)expr;
+		auto &colref = expr.Cast<BoundColumnRefExpression>();
 		bindings.push_back(colref.binding);
 	}
 	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { ExtractFilterBindings(child, bindings); });
@@ -19,7 +19,7 @@ static void ExtractFilterBindings(Expression &expr, vector<ColumnBinding> &bindi
 
 static unique_ptr<Expression> ReplaceGroupBindings(LogicalAggregate &proj, unique_ptr<Expression> expr) {
 	if (expr->type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &colref = (BoundColumnRefExpression &)*expr;
+		auto &colref = expr->Cast<BoundColumnRefExpression>();
 		D_ASSERT(colref.binding.table_index == proj.group_index);
 		D_ASSERT(colref.binding.column_index < proj.groups.size());
 		D_ASSERT(colref.depth == 0);
@@ -33,7 +33,7 @@ static unique_ptr<Expression> ReplaceGroupBindings(LogicalAggregate &proj, uniqu
 
 unique_ptr<LogicalOperator> FilterPushdown::PushdownAggregate(unique_ptr<LogicalOperator> op) {
 	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY);
-	auto &aggr = (LogicalAggregate &)*op;
+	auto &aggr = op->Cast<LogicalAggregate>();
 
 	// pushdown into AGGREGATE and GROUP BY
 	// we cannot push expressions that refer to the aggregate

package/src/duckdb/src/optimizer/pushdown/pushdown_filter.cpp

@@ -8,7 +8,7 @@ using Filter = FilterPushdown::Filter;
 
 unique_ptr<LogicalOperator> FilterPushdown::PushdownFilter(unique_ptr<LogicalOperator> op) {
 	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_FILTER);
-	auto &filter = (LogicalFilter &)*op;
+	auto &filter = op->Cast<LogicalFilter>();
 	if (!filter.projection_map.empty()) {
 		return FinishPushdown(std::move(op));
 	}

package/src/duckdb/src/optimizer/pushdown/pushdown_get.cpp

@@ -10,7 +10,7 @@ namespace duckdb {
 
 unique_ptr<LogicalOperator> FilterPushdown::PushdownGet(unique_ptr<LogicalOperator> op) {
 	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_GET);
-	auto &get = (LogicalGet &)*op;
+	auto &get = op->Cast<LogicalGet>();
 
 	if (get.function.pushdown_complex_filter || get.function.filter_pushdown) {
 		// this scan supports some form of filter push-down

package/src/duckdb/src/optimizer/pushdown/pushdown_inner_join.cpp

@@ -11,14 +11,14 @@ using Filter = FilterPushdown::Filter;
 unique_ptr<LogicalOperator> FilterPushdown::PushdownInnerJoin(unique_ptr<LogicalOperator> op,
                                                               unordered_set<idx_t> &left_bindings,
                                                               unordered_set<idx_t> &right_bindings) {
-	auto &join = (LogicalJoin &)*op;
+	auto &join = op->Cast<LogicalJoin>();
 	D_ASSERT(join.join_type == JoinType::INNER);
 	if (op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
 		return FinishPushdown(std::move(op));
 	}
 	// inner join: gather all the conditions of the inner join and add to the filter list
 	if (op->type == LogicalOperatorType::LOGICAL_ANY_JOIN) {
-		auto &any_join = (LogicalAnyJoin &)join;
+		auto &any_join = join.Cast<LogicalAnyJoin>();
 		// any join: only one filter to add
 		if (AddFilter(std::move(any_join.condition)) == FilterResult::UNSATISFIABLE) {
 			// filter statically evaluates to false, strip tree
@@ -30,7 +30,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownInnerJoin(unique_ptr<Logical
 	} else {
 		// comparison join
 		D_ASSERT(op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN);
-		auto &comp_join = (LogicalComparisonJoin &)join;
+		auto &comp_join = join.Cast<LogicalComparisonJoin>();
 		// turn the conditions into filters
 		for (auto &i : comp_join.conditions) {
 			auto condition = JoinCondition::CreateExpression(std::move(i));

package/src/duckdb/src/optimizer/pushdown/pushdown_left_join.cpp

@@ -14,7 +14,7 @@ using Filter = FilterPushdown::Filter;
 
 static unique_ptr<Expression> ReplaceColRefWithNull(unique_ptr<Expression> expr, unordered_set<idx_t> &right_bindings) {
 	if (expr->type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &bound_colref = (BoundColumnRefExpression &)*expr;
+		auto &bound_colref = expr->Cast<BoundColumnRefExpression>();
 		if (right_bindings.find(bound_colref.binding.table_index) != right_bindings.end()) {
 			// bound colref belongs to RHS
 			// replace it with a constant NULL
@@ -60,7 +60,7 @@ static bool FilterRemovesNull(ClientContext &context, ExpressionRewriter &rewrit
 unique_ptr<LogicalOperator> FilterPushdown::PushdownLeftJoin(unique_ptr<LogicalOperator> op,
                                                              unordered_set<idx_t> &left_bindings,
                                                              unordered_set<idx_t> &right_bindings) {
-	auto &join = (LogicalJoin &)*op;
+	auto &join = op->Cast<LogicalJoin>();
 	if (op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
 		return FinishPushdown(std::move(op));
 	}
@@ -72,7 +72,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownLeftJoin(unique_ptr<LogicalO
 	                           op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN);
 	if (isComparison) {
 		// add all comparison conditions
-		auto &comparison_join = (LogicalComparisonJoin &)*op;
+		auto &comparison_join = op->Cast<LogicalComparisonJoin>();
 		for (auto &cond : comparison_join.conditions) {
 			filter_combiner.AddFilter(
 			    make_uniq<BoundComparisonExpression>(cond.comparison, cond.left->Copy(), cond.right->Copy()));

package/src/duckdb/src/optimizer/pushdown/pushdown_limit.cpp

@@ -7,7 +7,7 @@
 namespace duckdb {
 
 unique_ptr<LogicalOperator> FilterPushdown::PushdownLimit(unique_ptr<LogicalOperator> op) {
-	auto &limit = (LogicalLimit &)*op;
+	auto &limit = op->Cast<LogicalLimit>();
 
 	if (!limit.limit && limit.limit_val == 0) {
 		return make_uniq<LogicalEmptyResult>(std::move(op));

package/src/duckdb/src/optimizer/pushdown/pushdown_mark_join.cpp

@@ -9,8 +9,8 @@ using Filter = FilterPushdown::Filter;
 unique_ptr<LogicalOperator> FilterPushdown::PushdownMarkJoin(unique_ptr<LogicalOperator> op,
                                                              unordered_set<idx_t> &left_bindings,
                                                              unordered_set<idx_t> &right_bindings) {
-	auto &join = (LogicalJoin &)*op;
-	auto &comp_join = (LogicalComparisonJoin &)*op;
+	auto &join = op->Cast<LogicalJoin>();
+	auto &comp_join = op->Cast<LogicalComparisonJoin>();
 	D_ASSERT(join.join_type == JoinType::MARK);
 	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
 	         op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN || op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN);
@@ -50,7 +50,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownMarkJoin(unique_ptr<LogicalO
 			// the MARK join is always TRUE or FALSE, and never NULL this happens in the case of a correlated EXISTS
 			// clause
 			if (filters[i]->filter->type == ExpressionType::OPERATOR_NOT) {
-				auto &op_expr = (BoundOperatorExpression &)*filters[i]->filter;
+				auto &op_expr = filters[i]->filter->Cast<BoundOperatorExpression>();
 				if (op_expr.children[0]->type == ExpressionType::BOUND_COLUMN_REF) {
 					// the filter is NOT(marker), check the join conditions
 					bool all_null_values_are_equal = true;

package/src/duckdb/src/optimizer/pushdown/pushdown_projection.cpp

@@ -8,7 +8,7 @@ namespace duckdb {
 
 static unique_ptr<Expression> ReplaceProjectionBindings(LogicalProjection &proj, unique_ptr<Expression> expr) {
 	if (expr->type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &colref = (BoundColumnRefExpression &)*expr;
+		auto &colref = expr->Cast<BoundColumnRefExpression>();
 		D_ASSERT(colref.binding.table_index == proj.table_index);
 		D_ASSERT(colref.binding.column_index < proj.expressions.size());
 		D_ASSERT(colref.depth == 0);
@@ -22,7 +22,7 @@ static unique_ptr<Expression> ReplaceProjectionBindings(LogicalProjection &proj,
 
 unique_ptr<LogicalOperator> FilterPushdown::PushdownProjection(unique_ptr<LogicalOperator> op) {
 	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_PROJECTION);
-	auto &proj = (LogicalProjection &)*op;
+	auto &proj = op->Cast<LogicalProjection>();
 	// push filter through logical projection
 	// all the BoundColumnRefExpressions in the filter should refer to the LogicalProjection
 	// we can rewrite them by replacing those references with the expression of the LogicalProjection node

package/src/duckdb/src/optimizer/pushdown/pushdown_set_operation.cpp

@@ -14,7 +14,7 @@ using Filter = FilterPushdown::Filter;
 static void ReplaceSetOpBindings(vector<ColumnBinding> &bindings, Filter &filter, Expression &expr,
                                  LogicalSetOperation &setop) {
 	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &colref = (BoundColumnRefExpression &)expr;
+		auto &colref = expr.Cast<BoundColumnRefExpression>();
 		D_ASSERT(colref.binding.table_index == setop.table_index);
 		D_ASSERT(colref.depth == 0);
 
@@ -30,7 +30,7 @@ static void ReplaceSetOpBindings(vector<ColumnBinding> &bindings, Filter &filter
 unique_ptr<LogicalOperator> FilterPushdown::PushdownSetOperation(unique_ptr<LogicalOperator> op) {
 	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_UNION || op->type == LogicalOperatorType::LOGICAL_EXCEPT ||
 	         op->type == LogicalOperatorType::LOGICAL_INTERSECT);
-	auto &setop = (LogicalSetOperation &)*op;
+	auto &setop = op->Cast<LogicalSetOperation>();
 
 	D_ASSERT(op->children.size() == 2);
 	auto left_bindings = op->children[0]->GetColumnBindings();
@@ -75,7 +75,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownSetOperation(unique_ptr<Logi
 		case LogicalOperatorType::LOGICAL_UNION:
 			if (op->children[1]->type == LogicalOperatorType::LOGICAL_PROJECTION) {
 				// union with empty left side: return right child
-				auto &projection = (LogicalProjection &)*op->children[1];
+				auto &projection = op->children[1]->Cast<LogicalProjection>();
 				projection.table_index = setop.table_index;
 				return std::move(op->children[1]);
 			}
@@ -95,7 +95,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownSetOperation(unique_ptr<Logi
 		case LogicalOperatorType::LOGICAL_EXCEPT:
 			if (op->children[0]->type == LogicalOperatorType::LOGICAL_PROJECTION) {
 				// union or except with empty right child: return left child
-				auto &projection = (LogicalProjection &)*op->children[0];
+				auto &projection = op->children[0]->Cast<LogicalProjection>();
 				projection.table_index = setop.table_index;
 				return std::move(op->children[0]);
 			}

package/src/duckdb/src/optimizer/pushdown/pushdown_single_join.cpp

@@ -8,7 +8,7 @@ using Filter = FilterPushdown::Filter;
 unique_ptr<LogicalOperator> FilterPushdown::PushdownSingleJoin(unique_ptr<LogicalOperator> op,
                                                                unordered_set<idx_t> &left_bindings,
                                                                unordered_set<idx_t> &right_bindings) {
-	D_ASSERT(((LogicalJoin &)*op).join_type == JoinType::SINGLE);
+	D_ASSERT(op->Cast<LogicalJoin>().join_type == JoinType::SINGLE);
 	FilterPushdown left_pushdown(optimizer), right_pushdown(optimizer);
 	// now check the set of filters
 	for (idx_t i = 0; i < filters.size(); i++) {

package/src/duckdb/src/optimizer/regex_range_filter.cpp

@@ -29,11 +29,11 @@ unique_ptr<LogicalOperator> RegexRangeFilter::Rewrite(unique_ptr<LogicalOperator
 
 	for (auto &expr : op->expressions) {
 		if (expr->type == ExpressionType::BOUND_FUNCTION) {
-			auto &func = (BoundFunctionExpression &)*expr.get();
+			auto &func = expr->Cast<BoundFunctionExpression>();
 			if (func.function.name != "regexp_full_match" || func.children.size() != 2) {
 				continue;
 			}
-			auto &info = (RegexpMatchesBindData &)*func.bind_info;
+			auto &info = func.bind_info->Cast<RegexpMatchesBindData>();
 			if (!info.range_success) {
 				continue;
 			}

package/src/duckdb/src/optimizer/remove_unused_columns.cpp

@@ -54,7 +54,7 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 		// aggregate
 		if (!everything_referenced) {
 			// FIXME: groups that are not referenced need to stay -> but they don't need to be scanned and output!
-			auto &aggr = (LogicalAggregate &)op;
+			auto &aggr = op.Cast<LogicalAggregate>();
 			ClearUnusedExpressions(aggr.expressions, aggr.aggregate_index);
 			if (aggr.expressions.empty() && aggr.groups.empty()) {
 				// removed all expressions from the aggregate: push a COUNT(*)
@@ -75,7 +75,7 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
 		if (!everything_referenced) {
-			auto &comp_join = (LogicalComparisonJoin &)op;
+			auto &comp_join = op.Cast<LogicalComparisonJoin>();
 
 			if (comp_join.join_type != JoinType::INNER) {
 				break;
@@ -89,8 +89,8 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 					    cond.right->expression_class == ExpressionClass::BOUND_COLUMN_REF) {
 						// comparison join between two bound column refs
 						// we can replace any reference to the RHS (build-side) with a reference to the LHS (probe-side)
-						auto &lhs_col = (BoundColumnRefExpression &)*cond.left;
-						auto &rhs_col = (BoundColumnRefExpression &)*cond.right;
+						auto &lhs_col = cond.left->Cast<BoundColumnRefExpression>();
+						auto &rhs_col = cond.right->Cast<BoundColumnRefExpression>();
 						// if there are any columns that refer to the RHS,
 						auto colrefs = column_references.find(rhs_col.binding);
 						if (colrefs != column_references.end()) {
@@ -113,7 +113,7 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 			// for UNION we can remove unreferenced columns as long as everything_referenced is false (i.e. we
 			// encounter a UNION node that is not preceded by a DISTINCT)
 			// this happens when UNION ALL is used
-			auto &setop = (LogicalSetOperation &)op;
+			auto &setop = op.Cast<LogicalSetOperation>();
 			vector<idx_t> entries;
 			for (idx_t i = 0; i < setop.column_count; i++) {
 				entries.push_back(i);
@@ -166,7 +166,7 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 		return;
 	case LogicalOperatorType::LOGICAL_ORDER_BY:
 		if (!everything_referenced) {
-			auto &order = (LogicalOrder &)op;
+			auto &order = op.Cast<LogicalOrder>();
 			D_ASSERT(order.projections.empty()); // should not yet be set
 			const auto all_bindings = order.GetColumnBindings();
 
@@ -183,7 +183,7 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 		return;
 	case LogicalOperatorType::LOGICAL_PROJECTION: {
 		if (!everything_referenced) {
-			auto &proj = (LogicalProjection &)op;
+			auto &proj = op.Cast<LogicalProjection>();
 			ClearUnusedExpressions(proj.expressions, proj.table_index);
 
 			if (proj.expressions.empty()) {
@@ -215,7 +215,7 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 	case LogicalOperatorType::LOGICAL_GET:
 		LogicalOperatorVisitor::VisitOperatorExpressions(op);
 		if (!everything_referenced) {
-			auto &get = (LogicalGet &)op;
+			auto &get = op.Cast<LogicalGet>();
 			if (!get.function.projection_pushdown) {
 				return;
 			}
@@ -283,7 +283,7 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 		}
 		return;
 	case LogicalOperatorType::LOGICAL_FILTER: {
-		auto &filter = (LogicalFilter &)op;
+		auto &filter = op.Cast<LogicalFilter>();
 		if (!filter.projection_map.empty()) {
 			// if we have any entries in the filter projection map don't prune any columns
 			// FIXME: we can do something more clever here
@@ -306,6 +306,10 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 		everything_referenced = true;
 		break;
 	}
+	case LogicalOperatorType::LOGICAL_PIVOT: {
+		everything_referenced = true;
+		break;
+	}
 	default:
 		break;
 	}

package/src/duckdb/src/optimizer/rule/arithmetic_simplification.cpp

@@ -24,46 +24,46 @@ ArithmeticSimplificationRule::ArithmeticSimplificationRule(ExpressionRewriter &r
 
 unique_ptr<Expression> ArithmeticSimplificationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
                                                            bool &changes_made, bool is_root) {
-	auto root = (BoundFunctionExpression *)bindings[0];
-	auto constant = (BoundConstantExpression *)bindings[1];
-	int constant_child = root->children[0].get() == constant ? 0 : 1;
-	D_ASSERT(root->children.size() == 2);
+	auto &root = bindings[0]->Cast<BoundFunctionExpression>();
+	auto &constant = bindings[1]->Cast<BoundConstantExpression>();
+	int constant_child = root.children[0].get() == &constant ? 0 : 1;
+	D_ASSERT(root.children.size() == 2);
 	(void)root;
 	// any arithmetic operator involving NULL is always NULL
-	if (constant->value.IsNull()) {
-		return make_uniq<BoundConstantExpression>(Value(root->return_type));
+	if (constant.value.IsNull()) {
+		return make_uniq<BoundConstantExpression>(Value(root.return_type));
 	}
-	auto &func_name = root->function.name;
+	auto &func_name = root.function.name;
 	if (func_name == "+") {
-		if (constant->value == 0) {
+		if (constant.value == 0) {
 			// addition with 0
 			// we can remove the entire operator and replace it with the non-constant child
-			return std::move(root->children[1 - constant_child]);
+			return std::move(root.children[1 - constant_child]);
 		}
 	} else if (func_name == "-") {
-		if (constant_child == 1 && constant->value == 0) {
+		if (constant_child == 1 && constant.value == 0) {
 			// subtraction by 0
 			// we can remove the entire operator and replace it with the non-constant child
-			return std::move(root->children[1 - constant_child]);
+			return std::move(root.children[1 - constant_child]);
 		}
 	} else if (func_name == "*") {
-		if (constant->value == 1) {
+		if (constant.value == 1) {
 			// multiply with 1, replace with non-constant child
-			return std::move(root->children[1 - constant_child]);
-		} else if (constant->value == 0) {
+			return std::move(root.children[1 - constant_child]);
+		} else if (constant.value == 0) {
 			// multiply by zero: replace with constant or null
-			return ExpressionRewriter::ConstantOrNull(std::move(root->children[1 - constant_child]),
-			                                          Value::Numeric(root->return_type, 0));
+			return ExpressionRewriter::ConstantOrNull(std::move(root.children[1 - constant_child]),
+			                                          Value::Numeric(root.return_type, 0));
 		}
 	} else {
 		D_ASSERT(func_name == "/");
 		if (constant_child == 1) {
-			if (constant->value == 1) {
+			if (constant.value == 1) {
 				// divide by 1, replace with non-constant child
-				return std::move(root->children[1 - constant_child]);
-			} else if (constant->value == 0) {
+				return std::move(root.children[1 - constant_child]);
+			} else if (constant.value == 0) {
 				// divide by 0, replace with NULL
-				return make_uniq<BoundConstantExpression>(Value(root->return_type));
+				return make_uniq<BoundConstantExpression>(Value(root.return_type));
 			}
 		}
 	}