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

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

@@ -13,9 +13,9 @@ CaseSimplificationRule::CaseSimplificationRule(ExpressionRewriter &rewriter) : R
 
 unique_ptr<Expression> CaseSimplificationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
                                                      bool &changes_made, bool is_root) {
-	auto root = (BoundCaseExpression *)bindings[0];
-	for (idx_t i = 0; i < root->case_checks.size(); i++) {
-		auto &case_check = root->case_checks[i];
+	auto &root = bindings[0]->Cast<BoundCaseExpression>();
+	for (idx_t i = 0; i < root.case_checks.size(); i++) {
+		auto &case_check = root.case_checks[i];
 		if (case_check.when_expr->IsFoldable()) {
 			// the WHEN check is a foldable expression
 			// use an ExpressionExecutor to execute the expression
@@ -25,21 +25,21 @@ unique_ptr<Expression> CaseSimplificationRule::Apply(LogicalOperator &op, vector
 			auto condition = constant_value.DefaultCastAs(LogicalType::BOOLEAN);
 			if (condition.IsNull() || !BooleanValue::Get(condition)) {
 				// the condition is always false: remove this case check
-				root->case_checks.erase(root->case_checks.begin() + i);
+				root.case_checks.erase(root.case_checks.begin() + i);
 				i--;
 			} else {
 				// the condition is always true
 				// move the THEN clause to the ELSE of the case
-				root->else_expr = std::move(case_check.then_expr);
+				root.else_expr = std::move(case_check.then_expr);
 				// remove this case check and any case checks after this one
-				root->case_checks.erase(root->case_checks.begin() + i, root->case_checks.end());
+				root.case_checks.erase(root.case_checks.begin() + i, root.case_checks.end());
 				break;
 			}
 		}
 	}
-	if (root->case_checks.empty()) {
+	if (root.case_checks.empty()) {
 		// no case checks left: return the ELSE expression
-		return std::move(root->else_expr);
+		return std::move(root.else_expr);
 	}
 	return nullptr;
 }

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

@@ -17,10 +17,10 @@ ComparisonSimplificationRule::ComparisonSimplificationRule(ExpressionRewriter &r
 unique_ptr<Expression> ComparisonSimplificationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
                                                            bool &changes_made, bool is_root) {
 	D_ASSERT(bindings[0]->expression_class == ExpressionClass::BOUND_COMPARISON);
-	auto expr = (BoundComparisonExpression *)bindings[0];
+	auto &expr = bindings[0]->Cast<BoundComparisonExpression>();
 	auto constant_expr = bindings[1];
-	bool column_ref_left = expr->left.get() != constant_expr;
-	auto column_ref_expr = !column_ref_left ? expr->right.get() : expr->left.get();
+	bool column_ref_left = expr.left.get() != constant_expr;
+	auto column_ref_expr = !column_ref_left ? expr.right.get() : expr.left.get();
 	// the constant_expr is a scalar expression that we have to fold
 	// use an ExpressionExecutor to execute the expression
 	D_ASSERT(constant_expr->IsFoldable());
@@ -28,8 +28,8 @@ unique_ptr<Expression> ComparisonSimplificationRule::Apply(LogicalOperator &op,
 	if (!ExpressionExecutor::TryEvaluateScalar(GetContext(), *constant_expr, constant_value)) {
 		return nullptr;
 	}
-	if (constant_value.IsNull() && !(expr->type == ExpressionType::COMPARE_NOT_DISTINCT_FROM ||
-	                                 expr->type == ExpressionType::COMPARE_DISTINCT_FROM)) {
+	if (constant_value.IsNull() && !(expr.type == ExpressionType::COMPARE_NOT_DISTINCT_FROM ||
+	                                 expr.type == ExpressionType::COMPARE_DISTINCT_FROM)) {
 		// comparison with constant NULL, return NULL
 		return make_uniq<BoundConstantExpression>(Value(LogicalType::BOOLEAN));
 	}
@@ -37,9 +37,9 @@ unique_ptr<Expression> ComparisonSimplificationRule::Apply(LogicalOperator &op,
 		//! Here we check if we can apply the expression on the constant side
 		//! We can do this if the cast itself is invertible and casting the constant is
 		//! invertible in practice.
-		auto cast_expression = (BoundCastExpression *)column_ref_expr;
-		auto target_type = cast_expression->source_type();
-		if (!BoundCastExpression::CastIsInvertible(target_type, cast_expression->return_type)) {
+		auto &cast_expression = column_ref_expr->Cast<BoundCastExpression>();
+		auto target_type = cast_expression.source_type();
+		if (!BoundCastExpression::CastIsInvertible(target_type, cast_expression.return_type)) {
 			return nullptr;
 		}
 
@@ -53,7 +53,7 @@ unique_ptr<Expression> ComparisonSimplificationRule::Apply(LogicalOperator &op,
 
 		// Is the constant cast invertible?
 		if (!cast_constant.IsNull() &&
-		    !BoundCastExpression::CastIsInvertible(cast_expression->return_type, target_type)) {
+		    !BoundCastExpression::CastIsInvertible(cast_expression.return_type, target_type)) {
 			// Is it actually invertible?
 			Value uncast_constant;
 			if (!cast_constant.DefaultTryCastAs(constant_value.type(), uncast_constant, &error_message, true) ||
@@ -63,14 +63,14 @@ unique_ptr<Expression> ComparisonSimplificationRule::Apply(LogicalOperator &op,
 		}
 
 		//! We can cast, now we change our column_ref_expression from an operator cast to a column reference
-		auto child_expression = std::move(cast_expression->child);
+		auto child_expression = std::move(cast_expression.child);
 		auto new_constant_expr = make_uniq<BoundConstantExpression>(cast_constant);
 		if (column_ref_left) {
-			expr->left = std::move(child_expression);
-			expr->right = std::move(new_constant_expr);
+			expr.left = std::move(child_expression);
+			expr.right = std::move(new_constant_expr);
 		} else {
-			expr->left = std::move(new_constant_expr);
-			expr->right = std::move(child_expression);
+			expr.left = std::move(new_constant_expr);
+			expr.right = std::move(child_expression);
 		}
 	}
 	return nullptr;

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

@@ -32,7 +32,7 @@ unique_ptr<Expression> ConjunctionSimplificationRule::RemoveExpression(BoundConj
 
 unique_ptr<Expression> ConjunctionSimplificationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
                                                             bool &changes_made, bool is_root) {
-	auto conjunction = (BoundConjunctionExpression *)bindings[0];
+	auto &conjunction = bindings[0]->Cast<BoundConjunctionExpression>();
 	auto constant_expr = bindings[1];
 	// the constant_expr is a scalar expression that we have to fold
 	// use an ExpressionExecutor to execute the expression
@@ -46,19 +46,19 @@ unique_ptr<Expression> ConjunctionSimplificationRule::Apply(LogicalOperator &op,
 		// we can't simplify conjunctions with a constant NULL
 		return nullptr;
 	}
-	if (conjunction->type == ExpressionType::CONJUNCTION_AND) {
+	if (conjunction.type == ExpressionType::CONJUNCTION_AND) {
 		if (!BooleanValue::Get(constant_value)) {
 			// FALSE in AND, result of expression is false
 			return make_uniq<BoundConstantExpression>(Value::BOOLEAN(false));
 		} else {
 			// TRUE in AND, remove the expression from the set
-			return RemoveExpression(*conjunction, constant_expr);
+			return RemoveExpression(conjunction, constant_expr);
 		}
 	} else {
-		D_ASSERT(conjunction->type == ExpressionType::CONJUNCTION_OR);
+		D_ASSERT(conjunction.type == ExpressionType::CONJUNCTION_OR);
 		if (!BooleanValue::Get(constant_value)) {
 			// FALSE in OR, remove the expression from the set
-			return RemoveExpression(*conjunction, constant_expr);
+			return RemoveExpression(conjunction, constant_expr);
 		} else {
 			// TRUE in OR, result of expression is true
 			return make_uniq<BoundConstantExpression>(Value::BOOLEAN(true));

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

@@ -22,8 +22,8 @@ DatePartSimplificationRule::DatePartSimplificationRule(ExpressionRewriter &rewri
 
 unique_ptr<Expression> DatePartSimplificationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
                                                          bool &changes_made, bool is_root) {
-	auto &date_part = (BoundFunctionExpression &)*bindings[0];
-	auto &constant_expr = (BoundConstantExpression &)*bindings[1];
+	auto &date_part = bindings[0]->Cast<BoundFunctionExpression>();
+	auto &constant_expr = bindings[1]->Cast<BoundConstantExpression>();
 	auto &constant = constant_expr.value;
 
 	if (constant.IsNull()) {

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

@@ -16,7 +16,7 @@ DistributivityRule::DistributivityRule(ExpressionRewriter &rewriter) : Rule(rewr
 
 void DistributivityRule::AddExpressionSet(Expression &expr, expression_set_t &set) {
 	if (expr.type == ExpressionType::CONJUNCTION_AND) {
-		auto &and_expr = (BoundConjunctionExpression &)expr;
+		auto &and_expr = expr.Cast<BoundConjunctionExpression>();
 		for (auto &child : and_expr.children) {
 			set.insert(child.get());
 		}
@@ -31,7 +31,7 @@ unique_ptr<Expression> DistributivityRule::ExtractExpression(BoundConjunctionExp
 	unique_ptr<Expression> result;
 	if (child->type == ExpressionType::CONJUNCTION_AND) {
 		// AND, remove expression from the list
-		auto &and_expr = (BoundConjunctionExpression &)*child;
+		auto &and_expr = child->Cast<BoundConjunctionExpression>();
 		for (idx_t i = 0; i < and_expr.children.size(); i++) {
 			if (Expression::Equals(and_expr.children[i].get(), &expr)) {
 				result = std::move(and_expr.children[i]);
@@ -55,20 +55,20 @@ unique_ptr<Expression> DistributivityRule::ExtractExpression(BoundConjunctionExp
 
 unique_ptr<Expression> DistributivityRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
                                                  bool &changes_made, bool is_root) {
-	auto initial_or = (BoundConjunctionExpression *)bindings[0];
+	auto &initial_or = bindings[0]->Cast<BoundConjunctionExpression>();
 
 	// we want to find expressions that occur in each of the children of the OR
 	// i.e. (X AND A) OR (X AND B) => X occurs in all branches
 	// first, for the initial child, we create an expression set of which expressions occur
 	// this is our initial candidate set (in the example: [X, A])
 	expression_set_t candidate_set;
-	AddExpressionSet(*initial_or->children[0], candidate_set);
+	AddExpressionSet(*initial_or.children[0], candidate_set);
 	// now for each of the remaining children, we create a set again and intersect them
 	// in our example: the second set would be [X, B]
 	// the intersection would leave [X]
-	for (idx_t i = 1; i < initial_or->children.size(); i++) {
+	for (idx_t i = 1; i < initial_or.children.size(); i++) {
 		expression_set_t next_set;
-		AddExpressionSet(*initial_or->children[i], next_set);
+		AddExpressionSet(*initial_or.children[i], next_set);
 		expression_set_t intersect_result;
 		for (auto &expr : candidate_set) {
 			if (next_set.find(expr) != next_set.end()) {
@@ -85,13 +85,13 @@ unique_ptr<Expression> DistributivityRule::Apply(LogicalOperator &op, vector<Exp
 	// the OR
 	auto new_root = make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND);
 	for (auto &expr : candidate_set) {
-		D_ASSERT(initial_or->children.size() > 0);
+		D_ASSERT(initial_or.children.size() > 0);
 
 		// extract the expression from the first child of the OR
-		auto result = ExtractExpression(*initial_or, 0, (Expression &)*expr);
+		auto result = ExtractExpression(initial_or, 0, (Expression &)*expr);
 		// now for the subsequent expressions, simply remove the expression
-		for (idx_t i = 1; i < initial_or->children.size(); i++) {
-			ExtractExpression(*initial_or, i, *result);
+		for (idx_t i = 1; i < initial_or.children.size(); i++) {
+			ExtractExpression(initial_or, i, *result);
 		}
 		// now we add the expression to the new root
 		new_root->children.push_back(std::move(result));
@@ -104,8 +104,8 @@ unique_ptr<Expression> DistributivityRule::Apply(LogicalOperator &op, vector<Exp
 	// X OR (X AND A) is the same as "X"
 	// since (1) only tuples that do not qualify "X" will not pass this predicate
 	//   and (2) all tuples that qualify "X" will pass this predicate
-	for (idx_t i = 0; i < initial_or->children.size(); i++) {
-		if (!initial_or->children[i]) {
+	for (idx_t i = 0; i < initial_or.children.size(); i++) {
+		if (!initial_or.children[i]) {
 			if (new_root->children.size() <= 1) {
 				return std::move(new_root->children[0]);
 			} else {
@@ -114,13 +114,13 @@ unique_ptr<Expression> DistributivityRule::Apply(LogicalOperator &op, vector<Exp
 		}
 	}
 	// finally we need to add the remaining expressions in the OR to the new root
-	if (initial_or->children.size() == 1) {
+	if (initial_or.children.size() == 1) {
 		// one child: skip the OR entirely and only add the single child
-		new_root->children.push_back(std::move(initial_or->children[0]));
-	} else if (initial_or->children.size() > 1) {
+		new_root->children.push_back(std::move(initial_or.children[0]));
+	} else if (initial_or.children.size() > 1) {
 		// multiple children still remain: push them into a new OR and add that to the new root
 		auto new_or = make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_OR);
-		for (auto &child : initial_or->children) {
+		for (auto &child : initial_or.children) {
 			new_or->children.push_back(std::move(child));
 		}
 		new_root->children.push_back(std::move(new_or));

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

@@ -23,16 +23,15 @@ EmptyNeedleRemovalRule::EmptyNeedleRemovalRule(ExpressionRewriter &rewriter) : R
 
 unique_ptr<Expression> EmptyNeedleRemovalRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
                                                      bool &changes_made, bool is_root) {
-	auto root = (BoundFunctionExpression *)bindings[0];
-	D_ASSERT(root->children.size() == 2);
-	(void)root;
+	auto &root = bindings[0]->Cast<BoundFunctionExpression>();
+	D_ASSERT(root.children.size() == 2);
 	auto prefix_expr = bindings[2];
 
 	// the constant_expr is a scalar expression that we have to fold
 	if (!prefix_expr->IsFoldable()) {
 		return nullptr;
 	}
-	D_ASSERT(root->return_type.id() == LogicalTypeId::BOOLEAN);
+	D_ASSERT(root.return_type.id() == LogicalTypeId::BOOLEAN);
 
 	auto prefix_value = ExpressionExecutor::EvaluateScalar(GetContext(), *prefix_expr);
 
@@ -47,7 +46,7 @@ unique_ptr<Expression> EmptyNeedleRemovalRule::Apply(LogicalOperator &op, vector
 	// PREFIX(NULL, '') is NULL
 	// so rewrite PREFIX(x, '') to TRUE_OR_NULL(x)
 	if (needle_string.empty()) {
-		return ExpressionRewriter::ConstantOrNull(std::move(root->children[0]), Value::BOOLEAN(true));
+		return ExpressionRewriter::ConstantOrNull(std::move(root.children[0]), Value::BOOLEAN(true));
 	}
 	return nullptr;
 }

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

@@ -47,14 +47,14 @@ bool AreMatchesPossible(LogicalType &left, LogicalType &right) {
 unique_ptr<Expression> EnumComparisonRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
                                                  bool &changes_made, bool is_root) {
 
-	auto root = (BoundComparisonExpression *)bindings[0];
-	auto left_child = (BoundCastExpression *)bindings[1];
-	auto right_child = (BoundCastExpression *)bindings[3];
+	auto &root = bindings[0]->Cast<BoundComparisonExpression>();
+	auto &left_child = bindings[1]->Cast<BoundCastExpression>();
+	auto &right_child = bindings[3]->Cast<BoundCastExpression>();
 
-	if (!AreMatchesPossible(left_child->child->return_type, right_child->child->return_type)) {
+	if (!AreMatchesPossible(left_child.child->return_type, right_child.child->return_type)) {
 		vector<unique_ptr<Expression>> children;
-		children.push_back(std::move(root->left));
-		children.push_back(std::move(root->right));
+		children.push_back(std::move(root.left));
+		children.push_back(std::move(root.right));
 		return ExpressionRewriter::ConstantOrNull(std::move(children), Value::BOOLEAN(false));
 	}
 
@@ -63,9 +63,8 @@ unique_ptr<Expression> EnumComparisonRule::Apply(LogicalOperator &op, vector<Exp
 	}
 
 	auto cast_left_to_right =
-	    BoundCastExpression::AddDefaultCastToType(std::move(left_child->child), right_child->child->return_type, true);
-	return make_uniq<BoundComparisonExpression>(root->type, std::move(cast_left_to_right),
-	                                            std::move(right_child->child));
+	    BoundCastExpression::AddDefaultCastToType(std::move(left_child.child), right_child.child->return_type, true);
+	return make_uniq<BoundComparisonExpression>(root.type, std::move(cast_left_to_right), std::move(right_child.child));
 }
 
 } // namespace duckdb

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

@@ -15,27 +15,27 @@ InClauseSimplificationRule::InClauseSimplificationRule(ExpressionRewriter &rewri
 unique_ptr<Expression> InClauseSimplificationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
                                                          bool &changes_made, bool is_root) {
 	D_ASSERT(bindings[0]->expression_class == ExpressionClass::BOUND_OPERATOR);
-	auto expr = (BoundOperatorExpression *)bindings[0];
-	if (expr->children[0]->expression_class != ExpressionClass::BOUND_CAST) {
+	auto &expr = bindings[0]->Cast<BoundOperatorExpression>();
+	if (expr.children[0]->expression_class != ExpressionClass::BOUND_CAST) {
 		return nullptr;
 	}
-	auto cast_expression = (BoundCastExpression *)expr->children[0].get();
-	if (cast_expression->child->expression_class != ExpressionClass::BOUND_COLUMN_REF) {
+	auto &cast_expression = expr.children[0]->Cast<BoundCastExpression>();
+	if (cast_expression.child->expression_class != ExpressionClass::BOUND_COLUMN_REF) {
 		return nullptr;
 	}
 	//! Here we check if we can apply the expression on the constant side
-	auto target_type = cast_expression->source_type();
-	if (!BoundCastExpression::CastIsInvertible(cast_expression->return_type, target_type)) {
+	auto target_type = cast_expression.source_type();
+	if (!BoundCastExpression::CastIsInvertible(cast_expression.return_type, target_type)) {
 		return nullptr;
 	}
 	vector<unique_ptr<BoundConstantExpression>> cast_list;
 	//! First check if we can cast all children
-	for (size_t i = 1; i < expr->children.size(); i++) {
-		if (expr->children[i]->expression_class != ExpressionClass::BOUND_CONSTANT) {
+	for (size_t i = 1; i < expr.children.size(); i++) {
+		if (expr.children[i]->expression_class != ExpressionClass::BOUND_CONSTANT) {
 			return nullptr;
 		}
-		D_ASSERT(expr->children[i]->IsFoldable());
-		auto constant_value = ExpressionExecutor::EvaluateScalar(GetContext(), *expr->children[i]);
+		D_ASSERT(expr.children[i]->IsFoldable());
+		auto constant_value = ExpressionExecutor::EvaluateScalar(GetContext(), *expr.children[i]);
 		auto new_constant = constant_value.DefaultTryCastAs(target_type);
 		if (!new_constant) {
 			return nullptr;
@@ -45,13 +45,13 @@ unique_ptr<Expression> InClauseSimplificationRule::Apply(LogicalOperator &op, ve
 		}
 	}
 	//! We can cast, so we move the new constant
-	for (size_t i = 1; i < expr->children.size(); i++) {
-		expr->children[i] = std::move(cast_list[i - 1]);
+	for (size_t i = 1; i < expr.children.size(); i++) {
+		expr.children[i] = std::move(cast_list[i - 1]);
 
 		//		expr->children[i] = std::move(new_constant_expr);
 	}
 	//! We can cast the full list, so we move the column
-	expr->children[0] = std::move(cast_expression->child);
+	expr.children[0] = std::move(cast_expression.child);
 	return nullptr;
 }
 

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

@@ -101,29 +101,29 @@ static bool PatternIsContains(const string &pattern) {
 
 unique_ptr<Expression> LikeOptimizationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
                                                    bool &changes_made, bool is_root) {
-	auto root = (BoundFunctionExpression *)bindings[0];
-	auto constant_expr = (BoundConstantExpression *)bindings[2];
-	D_ASSERT(root->children.size() == 2);
+	auto &root = bindings[0]->Cast<BoundFunctionExpression>();
+	auto &constant_expr = bindings[2]->Cast<BoundConstantExpression>();
+	D_ASSERT(root.children.size() == 2);
 
-	if (constant_expr->value.IsNull()) {
-		return make_uniq<BoundConstantExpression>(Value(root->return_type));
+	if (constant_expr.value.IsNull()) {
+		return make_uniq<BoundConstantExpression>(Value(root.return_type));
 	}
 
 	// the constant_expr is a scalar expression that we have to fold
-	if (!constant_expr->IsFoldable()) {
+	if (!constant_expr.IsFoldable()) {
 		return nullptr;
 	}
 
-	auto constant_value = ExpressionExecutor::EvaluateScalar(GetContext(), *constant_expr);
-	D_ASSERT(constant_value.type() == constant_expr->return_type);
+	auto constant_value = ExpressionExecutor::EvaluateScalar(GetContext(), constant_expr);
+	D_ASSERT(constant_value.type() == constant_expr.return_type);
 	auto &patt_str = StringValue::Get(constant_value);
 
-	bool is_not_like = root->function.name == "!~~";
+	bool is_not_like = root.function.name == "!~~";
 	if (PatternIsConstant(patt_str)) {
 		// Pattern is constant
 		return make_uniq<BoundComparisonExpression>(is_not_like ? ExpressionType::COMPARE_NOTEQUAL
 		                                                        : ExpressionType::COMPARE_EQUAL,
-		                                            std::move(root->children[0]), std::move(root->children[1]));
+		                                            std::move(root.children[0]), std::move(root.children[1]));
 	} else if (PatternIsPrefix(patt_str)) {
 		// Prefix LIKE pattern : [^%_]*[%]+, ignoring underscore
 		return ApplyRule(root, PrefixFun::GetFunction(), patt_str, is_not_like);
@@ -137,12 +137,12 @@ unique_ptr<Expression> LikeOptimizationRule::Apply(LogicalOperator &op, vector<E
 	return nullptr;
 }
 
-unique_ptr<Expression> LikeOptimizationRule::ApplyRule(BoundFunctionExpression *expr, ScalarFunction function,
+unique_ptr<Expression> LikeOptimizationRule::ApplyRule(BoundFunctionExpression &expr, ScalarFunction function,
                                                        string pattern, bool is_not_like) {
 	// replace LIKE by an optimized function
 	unique_ptr<Expression> result;
 	auto new_function =
-	    make_uniq<BoundFunctionExpression>(expr->return_type, std::move(function), std::move(expr->children), nullptr);
+	    make_uniq<BoundFunctionExpression>(expr.return_type, std::move(function), std::move(expr.children), nullptr);
 
 	// removing "%" from the pattern
 	pattern.erase(std::remove(pattern.begin(), pattern.end(), '%'), pattern.end());

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

@@ -30,22 +30,22 @@ MoveConstantsRule::MoveConstantsRule(ExpressionRewriter &rewriter) : Rule(rewrit
 
 unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
                                                 bool is_root) {
-	auto comparison = (BoundComparisonExpression *)bindings[0];
-	auto outer_constant = (BoundConstantExpression *)bindings[1];
-	auto arithmetic = (BoundFunctionExpression *)bindings[2];
-	auto inner_constant = (BoundConstantExpression *)bindings[3];
-	if (!TypeIsIntegral(arithmetic->return_type.InternalType())) {
+	auto &comparison = bindings[0]->Cast<BoundComparisonExpression>();
+	auto &outer_constant = bindings[1]->Cast<BoundConstantExpression>();
+	auto &arithmetic = bindings[2]->Cast<BoundFunctionExpression>();
+	auto &inner_constant = bindings[3]->Cast<BoundConstantExpression>();
+	if (!TypeIsIntegral(arithmetic.return_type.InternalType())) {
 		return nullptr;
 	}
-	if (inner_constant->value.IsNull() || outer_constant->value.IsNull()) {
-		return make_uniq<BoundConstantExpression>(Value(comparison->return_type));
+	if (inner_constant.value.IsNull() || outer_constant.value.IsNull()) {
+		return make_uniq<BoundConstantExpression>(Value(comparison.return_type));
 	}
-	auto &constant_type = outer_constant->return_type;
-	hugeint_t outer_value = IntegralValue::Get(outer_constant->value);
-	hugeint_t inner_value = IntegralValue::Get(inner_constant->value);
+	auto &constant_type = outer_constant.return_type;
+	hugeint_t outer_value = IntegralValue::Get(outer_constant.value);
+	hugeint_t inner_value = IntegralValue::Get(inner_constant.value);
 
-	idx_t arithmetic_child_index = arithmetic->children[0].get() == inner_constant ? 1 : 0;
-	auto &op_type = arithmetic->function.name;
+	idx_t arithmetic_child_index = arithmetic.children[0].get() == &inner_constant ? 1 : 0;
+	auto &op_type = arithmetic.function.name;
 	if (op_type == "+") {
 		// [x + 1 COMP 10] OR [1 + x COMP 10]
 		// order does not matter in addition:
@@ -58,10 +58,10 @@ unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<Expr
 			// if the cast is not possible then the comparison is not possible
 			// for example, if we have x + 5 = 3, where x is an unsigned number, we will get x = -2
 			// since this is not possible we can remove the entire branch here
-			return ExpressionRewriter::ConstantOrNull(std::move(arithmetic->children[arithmetic_child_index]),
+			return ExpressionRewriter::ConstantOrNull(std::move(arithmetic.children[arithmetic_child_index]),
 			                                          Value::BOOLEAN(false));
 		}
-		outer_constant->value = std::move(result_value);
+		outer_constant.value = std::move(result_value);
 	} else if (op_type == "-") {
 		// [x - 1 COMP 10] O R [1 - x COMP 10]
 		// order matters in subtraction:
@@ -74,13 +74,13 @@ unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<Expr
 			auto result_value = Value::HUGEINT(outer_value);
 			if (!result_value.DefaultTryCastAs(constant_type)) {
 				// if the cast is not possible then an equality comparison is not possible
-				if (comparison->type != ExpressionType::COMPARE_EQUAL) {
+				if (comparison.type != ExpressionType::COMPARE_EQUAL) {
 					return nullptr;
 				}
-				return ExpressionRewriter::ConstantOrNull(std::move(arithmetic->children[arithmetic_child_index]),
+				return ExpressionRewriter::ConstantOrNull(std::move(arithmetic.children[arithmetic_child_index]),
 				                                          Value::BOOLEAN(false));
 			}
-			outer_constant->value = std::move(result_value);
+			outer_constant.value = std::move(result_value);
 		} else {
 			// [1 - x COMP 10]
 			// change right side to 1-10=-9
@@ -90,16 +90,16 @@ unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<Expr
 			auto result_value = Value::HUGEINT(inner_value);
 			if (!result_value.DefaultTryCastAs(constant_type)) {
 				// if the cast is not possible then an equality comparison is not possible
-				if (comparison->type != ExpressionType::COMPARE_EQUAL) {
+				if (comparison.type != ExpressionType::COMPARE_EQUAL) {
 					return nullptr;
 				}
-				return ExpressionRewriter::ConstantOrNull(std::move(arithmetic->children[arithmetic_child_index]),
+				return ExpressionRewriter::ConstantOrNull(std::move(arithmetic.children[arithmetic_child_index]),
 				                                          Value::BOOLEAN(false));
 			}
-			outer_constant->value = std::move(result_value);
+			outer_constant.value = std::move(result_value);
 			// in this case, we should also flip the comparison
 			// e.g. if we have [4 - x < 2] then we should have [x > 2]
-			comparison->type = FlipComparisonExpression(comparison->type);
+			comparison.type = FlipComparisonExpression(comparison.type);
 		}
 	} else {
 		D_ASSERT(op_type == "*");
@@ -114,13 +114,13 @@ unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<Expr
 		}
 		if (outer_value % inner_value != 0) {
 			// not cleanly divisible
-			bool is_equality = comparison->type == ExpressionType::COMPARE_EQUAL;
-			bool is_inequality = comparison->type == ExpressionType::COMPARE_NOTEQUAL;
+			bool is_equality = comparison.type == ExpressionType::COMPARE_EQUAL;
+			bool is_inequality = comparison.type == ExpressionType::COMPARE_NOTEQUAL;
 			if (is_equality || is_inequality) {
 				// we know the values are not equal
 				// the result will be either FALSE or NULL (if COMPARE_EQUAL)
 				// or TRUE or NULL (if COMPARE_NOTEQUAL)
-				return ExpressionRewriter::ConstantOrNull(std::move(arithmetic->children[arithmetic_child_index]),
+				return ExpressionRewriter::ConstantOrNull(std::move(arithmetic.children[arithmetic_child_index]),
 				                                          Value::BOOLEAN(is_inequality));
 			} else {
 				// not cleanly divisible and we are doing > >= < <=, skip the simplification for now
@@ -129,26 +129,26 @@ unique_ptr<Expression> MoveConstantsRule::Apply(LogicalOperator &op, vector<Expr
 		}
 		if (inner_value < 0) {
 			// multiply by negative value, need to flip expression
-			comparison->type = FlipComparisonExpression(comparison->type);
+			comparison.type = FlipComparisonExpression(comparison.type);
 		}
 		// else divide the RHS by the LHS
 		// we need to do a range check on the cast even though we do a division
 		// because e.g. -128 / -1 = 128, which is out of range
 		auto result_value = Value::HUGEINT(outer_value / inner_value);
 		if (!result_value.DefaultTryCastAs(constant_type)) {
-			return ExpressionRewriter::ConstantOrNull(std::move(arithmetic->children[arithmetic_child_index]),
+			return ExpressionRewriter::ConstantOrNull(std::move(arithmetic.children[arithmetic_child_index]),
 			                                          Value::BOOLEAN(false));
 		}
-		outer_constant->value = std::move(result_value);
+		outer_constant.value = std::move(result_value);
 	}
 	// replace left side with x
 	// first extract x from the arithmetic expression
-	auto arithmetic_child = std::move(arithmetic->children[arithmetic_child_index]);
+	auto arithmetic_child = std::move(arithmetic.children[arithmetic_child_index]);
 	// then place in the comparison
-	if (comparison->left.get() == outer_constant) {
-		comparison->right = std::move(arithmetic_child);
+	if (comparison.left.get() == &outer_constant) {
+		comparison.right = std::move(arithmetic_child);
 	} else {
-		comparison->left = std::move(arithmetic_child);
+		comparison.left = std::move(arithmetic_child);
 	}
 	changes_made = true;
 	return nullptr;

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

@@ -13,14 +13,14 @@ OrderedAggregateOptimizer::OrderedAggregateOptimizer(ExpressionRewriter &rewrite
 
 unique_ptr<Expression> OrderedAggregateOptimizer::Apply(LogicalOperator &op, vector<Expression *> &bindings,
                                                         bool &changes_made, bool is_root) {
-	auto aggr = (BoundAggregateExpression *)bindings[0];
-	if (!aggr->order_bys) {
+	auto &aggr = bindings[0]->Cast<BoundAggregateExpression>();
+	if (!aggr.order_bys) {
 		// no ORDER BYs defined
 		return nullptr;
 	}
-	if (aggr->function.order_dependent == AggregateOrderDependent::NOT_ORDER_DEPENDENT) {
+	if (aggr.function.order_dependent == AggregateOrderDependent::NOT_ORDER_DEPENDENT) {
 		// not an order dependent aggregate but we have an ORDER BY clause - remove it
-		aggr->order_bys.reset();
+		aggr.order_bys.reset();
 		changes_made = true;
 		return nullptr;
 	}

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

@@ -20,21 +20,21 @@ RegexOptimizationRule::RegexOptimizationRule(ExpressionRewriter &rewriter) : Rul
 
 unique_ptr<Expression> RegexOptimizationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
                                                     bool &changes_made, bool is_root) {
-	auto root = (BoundFunctionExpression *)bindings[0];
-	auto constant_expr = (BoundConstantExpression *)bindings[2];
-	D_ASSERT(root->children.size() == 2);
+	auto &root = bindings[0]->Cast<BoundFunctionExpression>();
+	auto &constant_expr = bindings[2]->Cast<BoundConstantExpression>();
+	D_ASSERT(root.children.size() == 2);
 
-	if (constant_expr->value.IsNull()) {
-		return make_uniq<BoundConstantExpression>(Value(root->return_type));
+	if (constant_expr.value.IsNull()) {
+		return make_uniq<BoundConstantExpression>(Value(root.return_type));
 	}
 
 	// the constant_expr is a scalar expression that we have to fold
-	if (!constant_expr->IsFoldable()) {
+	if (!constant_expr.IsFoldable()) {
 		return nullptr;
 	}
 
-	auto constant_value = ExpressionExecutor::EvaluateScalar(GetContext(), *constant_expr);
-	D_ASSERT(constant_value.type() == constant_expr->return_type);
+	auto constant_value = ExpressionExecutor::EvaluateScalar(GetContext(), constant_expr);
+	D_ASSERT(constant_value.type() == constant_expr.return_type);
 	auto patt_str = StringValue::Get(constant_value);
 
 	duckdb_re2::RE2 pattern(patt_str);
@@ -44,8 +44,8 @@ unique_ptr<Expression> RegexOptimizationRule::Apply(LogicalOperator &op, vector<
 
 	if (pattern.Regexp()->op() == duckdb_re2::kRegexpLiteralString ||
 	    pattern.Regexp()->op() == duckdb_re2::kRegexpLiteral) {
-		auto contains = make_uniq<BoundFunctionExpression>(root->return_type, ContainsFun::GetFunction(),
-		                                                   std::move(root->children), nullptr);
+		auto contains = make_uniq<BoundFunctionExpression>(root.return_type, ContainsFun::GetFunction(),
+		                                                   std::move(root.children), nullptr);
 
 		string min;
 		string max;