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

package/src/duckdb/src/optimizer/statistics/operator/propagate_filter.cpp

@@ -4,6 +4,7 @@
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/planner/expression/bound_comparison_expression.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
+#include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/planner/operator/logical_filter.hpp"
 #include "duckdb/storage/statistics/base_statistics.hpp"
 
@@ -17,7 +18,7 @@ bool StatisticsPropagator::ExpressionIsConstant(Expression &expr, const Value &v
 	if (expr.GetExpressionClass() != ExpressionClass::BOUND_CONSTANT) {
 		return false;
 	}
-	auto &bound_constant = (BoundConstantExpression &)expr;
+	auto &bound_constant = expr.Cast<BoundConstantExpression>();
 	D_ASSERT(bound_constant.value.type() == val.type());
 	return Value::NotDistinctFrom(bound_constant.value, val);
 }
@@ -26,7 +27,7 @@ bool StatisticsPropagator::ExpressionIsConstantOrNull(Expression &expr, const Va
 	if (expr.GetExpressionClass() != ExpressionClass::BOUND_FUNCTION) {
 		return false;
 	}
-	auto &bound_function = (BoundFunctionExpression &)expr;
+	auto &bound_function = expr.Cast<BoundFunctionExpression>();
 	return ConstantOrNull::IsConstantOrNull(bound_function, val);
 }
 
@@ -154,10 +155,10 @@ void StatisticsPropagator::UpdateFilterStatistics(Expression &left, Expression &
 	// any column ref involved in a comparison will not be null after the comparison
 	bool compare_distinct = IsCompareDistinct(comparison_type);
 	if (!compare_distinct && left.type == ExpressionType::BOUND_COLUMN_REF) {
-		SetStatisticsNotNull(((BoundColumnRefExpression &)left).binding);
+		SetStatisticsNotNull((left.Cast<BoundColumnRefExpression>()).binding);
 	}
 	if (!compare_distinct && right.type == ExpressionType::BOUND_COLUMN_REF) {
-		SetStatisticsNotNull(((BoundColumnRefExpression &)right).binding);
+		SetStatisticsNotNull((right.Cast<BoundColumnRefExpression>()).binding);
 	}
 	// check if this is a comparison between a constant and a column ref
 	BoundConstantExpression *constant = nullptr;
@@ -171,8 +172,8 @@ void StatisticsPropagator::UpdateFilterStatistics(Expression &left, Expression &
 		constant = (BoundConstantExpression *)&right;
 	} else if (left.type == ExpressionType::BOUND_COLUMN_REF && right.type == ExpressionType::BOUND_COLUMN_REF) {
 		// comparison between two column refs
-		auto &left_column_ref = (BoundColumnRefExpression &)left;
-		auto &right_column_ref = (BoundColumnRefExpression &)right;
+		auto &left_column_ref = left.Cast<BoundColumnRefExpression>();
+		auto &right_column_ref = right.Cast<BoundColumnRefExpression>();
 		auto lentry = statistics_map.find(left_column_ref.binding);
 		auto rentry = statistics_map.find(right_column_ref.binding);
 		if (lentry == statistics_map.end() || rentry == statistics_map.end()) {
@@ -198,13 +199,13 @@ void StatisticsPropagator::UpdateFilterStatistics(Expression &condition) {
 	// if we find a comparison in the form of e.g. "i=3", we can update our statistics for that column
 	switch (condition.GetExpressionClass()) {
 	case ExpressionClass::BOUND_BETWEEN: {
-		auto &between = (BoundBetweenExpression &)condition;
+		auto &between = condition.Cast<BoundBetweenExpression>();
 		UpdateFilterStatistics(*between.input, *between.lower, between.LowerComparisonType());
 		UpdateFilterStatistics(*between.input, *between.upper, between.UpperComparisonType());
 		break;
 	}
 	case ExpressionClass::BOUND_COMPARISON: {
-		auto &comparison = (BoundComparisonExpression &)condition;
+		auto &comparison = condition.Cast<BoundComparisonExpression>();
 		UpdateFilterStatistics(*comparison.left, *comparison.right, comparison.type);
 		break;
 	}

package/src/duckdb/src/optimizer/statistics/operator/propagate_join.cpp

@@ -196,10 +196,10 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalJoin
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
 	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
-		PropagateStatistics((LogicalComparisonJoin &)join, node_ptr);
+		PropagateStatistics(join.Cast<LogicalComparisonJoin>(), node_ptr);
 		break;
 	case LogicalOperatorType::LOGICAL_ANY_JOIN:
-		PropagateStatistics((LogicalAnyJoin &)join, node_ptr);
+		PropagateStatistics(join.Cast<LogicalAnyJoin>(), node_ptr);
 		break;
 	default:
 		break;

package/src/duckdb/src/optimizer/statistics_propagator.cpp

@@ -3,7 +3,18 @@
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/logical_operator.hpp"
+#include "duckdb/planner/operator/logical_aggregate.hpp"
 #include "duckdb/planner/operator/logical_empty_result.hpp"
+#include "duckdb/planner/operator/logical_cross_product.hpp"
+#include "duckdb/planner/operator/logical_filter.hpp"
+#include "duckdb/planner/operator/logical_get.hpp"
+#include "duckdb/planner/operator/logical_join.hpp"
+#include "duckdb/planner/operator/logical_projection.hpp"
+#include "duckdb/planner/operator/logical_positional_join.hpp"
+#include "duckdb/planner/operator/logical_set_operation.hpp"
+#include "duckdb/planner/operator/logical_order.hpp"
+#include "duckdb/planner/operator/logical_window.hpp"
+#include "duckdb/planner/expression/list.hpp"
 
 namespace duckdb {
 
@@ -26,31 +37,31 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalOper
                                                                      unique_ptr<LogicalOperator> *node_ptr) {
 	switch (node.type) {
 	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY:
-		return PropagateStatistics((LogicalAggregate &)node, node_ptr);
+		return PropagateStatistics(node.Cast<LogicalAggregate>(), node_ptr);
 	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
-		return PropagateStatistics((LogicalCrossProduct &)node, node_ptr);
+		return PropagateStatistics(node.Cast<LogicalCrossProduct>(), node_ptr);
 	case LogicalOperatorType::LOGICAL_FILTER:
-		return PropagateStatistics((LogicalFilter &)node, node_ptr);
+		return PropagateStatistics(node.Cast<LogicalFilter>(), node_ptr);
 	case LogicalOperatorType::LOGICAL_GET:
-		return PropagateStatistics((LogicalGet &)node, node_ptr);
+		return PropagateStatistics(node.Cast<LogicalGet>(), node_ptr);
 	case LogicalOperatorType::LOGICAL_PROJECTION:
-		return PropagateStatistics((LogicalProjection &)node, node_ptr);
+		return PropagateStatistics(node.Cast<LogicalProjection>(), node_ptr);
 	case LogicalOperatorType::LOGICAL_ANY_JOIN:
 	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
 	case LogicalOperatorType::LOGICAL_JOIN:
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-		return PropagateStatistics((LogicalJoin &)node, node_ptr);
+		return PropagateStatistics(node.Cast<LogicalJoin>(), node_ptr);
 	case LogicalOperatorType::LOGICAL_POSITIONAL_JOIN:
-		return PropagateStatistics((LogicalPositionalJoin &)node, node_ptr);
+		return PropagateStatistics(node.Cast<LogicalPositionalJoin>(), node_ptr);
 	case LogicalOperatorType::LOGICAL_UNION:
 	case LogicalOperatorType::LOGICAL_EXCEPT:
 	case LogicalOperatorType::LOGICAL_INTERSECT:
-		return PropagateStatistics((LogicalSetOperation &)node, node_ptr);
+		return PropagateStatistics(node.Cast<LogicalSetOperation>(), node_ptr);
 	case LogicalOperatorType::LOGICAL_ORDER_BY:
-		return PropagateStatistics((LogicalOrder &)node, node_ptr);
+		return PropagateStatistics(node.Cast<LogicalOrder>(), node_ptr);
 	case LogicalOperatorType::LOGICAL_WINDOW:
-		return PropagateStatistics((LogicalWindow &)node, node_ptr);
+		return PropagateStatistics(node.Cast<LogicalWindow>(), node_ptr);
 	default:
 		return PropagateChildren(node, node_ptr);
 	}
@@ -64,25 +75,25 @@ unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(Expression
                                                                      unique_ptr<Expression> *expr_ptr) {
 	switch (expr.GetExpressionClass()) {
 	case ExpressionClass::BOUND_AGGREGATE:
-		return PropagateExpression((BoundAggregateExpression &)expr, expr_ptr);
+		return PropagateExpression(expr.Cast<BoundAggregateExpression>(), expr_ptr);
 	case ExpressionClass::BOUND_BETWEEN:
-		return PropagateExpression((BoundBetweenExpression &)expr, expr_ptr);
+		return PropagateExpression(expr.Cast<BoundBetweenExpression>(), expr_ptr);
 	case ExpressionClass::BOUND_CASE:
-		return PropagateExpression((BoundCaseExpression &)expr, expr_ptr);
+		return PropagateExpression(expr.Cast<BoundCaseExpression>(), expr_ptr);
 	case ExpressionClass::BOUND_CONJUNCTION:
-		return PropagateExpression((BoundConjunctionExpression &)expr, expr_ptr);
+		return PropagateExpression(expr.Cast<BoundConjunctionExpression>(), expr_ptr);
 	case ExpressionClass::BOUND_FUNCTION:
-		return PropagateExpression((BoundFunctionExpression &)expr, expr_ptr);
+		return PropagateExpression(expr.Cast<BoundFunctionExpression>(), expr_ptr);
 	case ExpressionClass::BOUND_CAST:
-		return PropagateExpression((BoundCastExpression &)expr, expr_ptr);
+		return PropagateExpression(expr.Cast<BoundCastExpression>(), expr_ptr);
 	case ExpressionClass::BOUND_COMPARISON:
-		return PropagateExpression((BoundComparisonExpression &)expr, expr_ptr);
+		return PropagateExpression(expr.Cast<BoundComparisonExpression>(), expr_ptr);
 	case ExpressionClass::BOUND_CONSTANT:
-		return PropagateExpression((BoundConstantExpression &)expr, expr_ptr);
+		return PropagateExpression(expr.Cast<BoundConstantExpression>(), expr_ptr);
 	case ExpressionClass::BOUND_COLUMN_REF:
-		return PropagateExpression((BoundColumnRefExpression &)expr, expr_ptr);
+		return PropagateExpression(expr.Cast<BoundColumnRefExpression>(), expr_ptr);
 	case ExpressionClass::BOUND_OPERATOR:
-		return PropagateExpression((BoundOperatorExpression &)expr, expr_ptr);
+		return PropagateExpression(expr.Cast<BoundOperatorExpression>(), expr_ptr);
 	default:
 		break;
 	}

package/src/duckdb/src/optimizer/topn_optimizer.cpp

@@ -9,8 +9,8 @@ namespace duckdb {
 unique_ptr<LogicalOperator> TopN::Optimize(unique_ptr<LogicalOperator> op) {
 	if (op->type == LogicalOperatorType::LOGICAL_LIMIT &&
 	    op->children[0]->type == LogicalOperatorType::LOGICAL_ORDER_BY) {
-		auto &limit = (LogicalLimit &)*op;
-		auto &order_by = (LogicalOrder &)*(op->children[0]);
+		auto &limit = op->Cast<LogicalLimit>();
+		auto &order_by = (op->children[0])->Cast<LogicalOrder>();
 
 		// This optimization doesn't apply when OFFSET is present without LIMIT
 		// Or if offset is not constant

package/src/duckdb/src/optimizer/unnest_rewriter.cpp

@@ -22,7 +22,7 @@ void UnnestRewriterPlanUpdater::VisitExpression(unique_ptr<Expression> *expressi
 
 	if (expr->expression_class == ExpressionClass::BOUND_COLUMN_REF) {
 
-		auto &bound_column_ref = (BoundColumnRefExpression &)*expr;
+		auto &bound_column_ref = expr->Cast<BoundColumnRefExpression>();
 		for (idx_t i = 0; i < replace_bindings.size(); i++) {
 			if (bound_column_ref.binding == replace_bindings[i].old_binding) {
 				bound_column_ref.binding = replace_bindings[i].new_binding;
@@ -79,7 +79,7 @@ void UnnestRewriter::FindCandidates(unique_ptr<LogicalOperator> *op_ptr,
 	}
 
 	// found a delim join
-	auto &delim_join = (LogicalDelimJoin &)*op->children[0];
+	auto &delim_join = op->children[0]->Cast<LogicalDelimJoin>();
 	// only support INNER delim joins
 	if (delim_join.join_type != JoinType::INNER) {
 		return;
@@ -144,9 +144,9 @@ bool UnnestRewriter::RewriteCandidate(unique_ptr<LogicalOperator> *candidate) {
 	// store the table index of the child of the LOGICAL_UNNEST
 	// then update the plan by making the lhs_proj the child of the LOGICAL_UNNEST
 	D_ASSERT(curr_op->get()->type == LogicalOperatorType::LOGICAL_UNNEST);
-	auto &unnest = (LogicalUnnest &)*curr_op->get();
+	auto &unnest = curr_op->get()->Cast<LogicalUnnest>();
 	D_ASSERT(unnest.children[0]->type == LogicalOperatorType::LOGICAL_DELIM_GET);
-	overwritten_tbl_idx = ((LogicalDelimGet &)*unnest.children[0]).table_index;
+	overwritten_tbl_idx = unnest.children[0]->Cast<LogicalDelimGet>().table_index;
 	unnest.children[0] = std::move(lhs_op);
 
 	// replace the LOGICAL_DELIM_JOIN with its RHS child operator
@@ -166,7 +166,7 @@ void UnnestRewriter::UpdateRHSBindings(unique_ptr<LogicalOperator> *plan_ptr, un
 
 		path_to_unnest.push_back(curr_op);
 		D_ASSERT(curr_op->get()->type == LogicalOperatorType::LOGICAL_PROJECTION);
-		auto &proj = (LogicalProjection &)*curr_op->get();
+		auto &proj = curr_op->get()->Cast<LogicalProjection>();
 
 		// pop the two last expressions from all projections (delim_idx and UNNEST column)
 		D_ASSERT(proj.expressions.size() > 2);
@@ -189,7 +189,7 @@ void UnnestRewriter::UpdateRHSBindings(unique_ptr<LogicalOperator> *plan_ptr, un
 
 	// update all bindings coming from the LHS to RHS bindings
 	D_ASSERT(topmost_op.children[0]->type == LogicalOperatorType::LOGICAL_PROJECTION);
-	auto &top_proj = (LogicalProjection &)*topmost_op.children[0];
+	auto &top_proj = topmost_op.children[0]->Cast<LogicalProjection>();
 	for (idx_t i = 0; i < lhs_bindings.size(); i++) {
 		ReplaceBinding replace_binding(lhs_bindings[i].binding, ColumnBinding(top_proj.table_index, i));
 		updater.replace_bindings.push_back(replace_binding);
@@ -197,7 +197,7 @@ void UnnestRewriter::UpdateRHSBindings(unique_ptr<LogicalOperator> *plan_ptr, un
 
 	// temporarily remove the BOUND_UNNEST and the child of the LOGICAL_UNNEST from the plan
 	D_ASSERT(curr_op->get()->type == LogicalOperatorType::LOGICAL_UNNEST);
-	auto &unnest = (LogicalUnnest &)*curr_op->get();
+	auto &unnest = curr_op->get()->Cast<LogicalUnnest>();
 	auto temp_bound_unnest = std::move(unnest.expressions[0]);
 	auto temp_unnest_child = std::move(unnest.children[0]);
 	unnest.expressions.clear();
@@ -213,7 +213,7 @@ void UnnestRewriter::UpdateRHSBindings(unique_ptr<LogicalOperator> *plan_ptr, un
 	for (idx_t i = path_to_unnest.size(); i > 0; i--) {
 
 		D_ASSERT(path_to_unnest[i - 1]->get()->type == LogicalOperatorType::LOGICAL_PROJECTION);
-		auto &proj = (LogicalProjection &)*path_to_unnest[i - 1]->get();
+		auto &proj = path_to_unnest[i - 1]->get()->Cast<LogicalProjection>();
 
 		// temporarily store the existing expressions
 		vector<unique_ptr<Expression>> existing_expressions;
@@ -254,7 +254,7 @@ void UnnestRewriter::UpdateBoundUnnestBindings(UnnestRewriterPlanUpdater &update
 
 	// found the LOGICAL_UNNEST
 	D_ASSERT(curr_op->get()->type == LogicalOperatorType::LOGICAL_UNNEST);
-	auto &unnest = (LogicalUnnest &)*curr_op->get();
+	auto &unnest = curr_op->get()->Cast<LogicalUnnest>();
 
 	auto unnest_child_cols = unnest.children[0]->GetColumnBindings();
 	for (idx_t delim_col_idx = 0; delim_col_idx < delim_columns.size(); delim_col_idx++) {
@@ -276,11 +276,11 @@ void UnnestRewriter::UpdateBoundUnnestBindings(UnnestRewriterPlanUpdater &update
 void UnnestRewriter::GetDelimColumns(LogicalOperator &op) {
 
 	D_ASSERT(op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
-	auto &delim_join = (LogicalDelimJoin &)op;
+	auto &delim_join = op.Cast<LogicalDelimJoin>();
 	for (idx_t i = 0; i < delim_join.duplicate_eliminated_columns.size(); i++) {
 		auto &expr = *delim_join.duplicate_eliminated_columns[i];
 		D_ASSERT(expr.type == ExpressionType::BOUND_COLUMN_REF);
-		auto &bound_colref_expr = (BoundColumnRefExpression &)expr;
+		auto &bound_colref_expr = expr.Cast<BoundColumnRefExpression>();
 		delim_columns.push_back(bound_colref_expr.binding);
 	}
 }
@@ -294,7 +294,7 @@ void UnnestRewriter::GetLHSExpressions(LogicalOperator &op) {
 	bool set_alias = false;
 	// we can easily extract the alias for LOGICAL_PROJECTION(s)
 	if (op.type == LogicalOperatorType::LOGICAL_PROJECTION) {
-		auto &proj = (LogicalProjection &)op;
+		auto &proj = op.Cast<LogicalProjection>();
 		if (proj.expressions.size() == op.types.size()) {
 			set_alias = true;
 		}
@@ -303,7 +303,7 @@ void UnnestRewriter::GetLHSExpressions(LogicalOperator &op) {
 	for (idx_t i = 0; i < op.types.size(); i++) {
 		lhs_bindings.emplace_back(col_bindings[i], op.types[i]);
 		if (set_alias) {
-			auto &proj = (LogicalProjection &)op;
+			auto &proj = op.Cast<LogicalProjection>();
 			lhs_bindings.back().alias = proj.expressions[i]->alias;
 		}
 	}

package/src/duckdb/src/parser/column_definition.cpp

@@ -145,7 +145,7 @@ bool ColumnDefinition::Generated() const {
 
 static void VerifyColumnRefs(ParsedExpression &expr) {
 	if (expr.type == ExpressionType::COLUMN_REF) {
-		auto &column_ref = (ColumnRefExpression &)expr;
+		auto &column_ref = expr.Cast<ColumnRefExpression>();
 		if (column_ref.IsQualified()) {
 			throw ParserException(
 			    "Qualified (tbl.name) column references are not allowed inside of generated column expressions");
@@ -157,7 +157,7 @@ static void VerifyColumnRefs(ParsedExpression &expr) {
 
 static void InnerGetListOfDependencies(ParsedExpression &expr, vector<string> &dependencies) {
 	if (expr.type == ExpressionType::COLUMN_REF) {
-		auto columnref = (ColumnRefExpression &)expr;
+		auto columnref = expr.Cast<ColumnRefExpression>();
 		auto &name = columnref.GetColumnName();
 		dependencies.push_back(name);
 	}
@@ -206,7 +206,7 @@ void ColumnDefinition::ChangeGeneratedExpressionType(const LogicalType &type) {
 	generated_expression = make_uniq_base<ParsedExpression, CastExpression>(type, std::move(generated_expression));
 	// Every generated expression should be wrapped in a cast on creation
 	// D_ASSERT(generated_expression->type == ExpressionType::OPERATOR_CAST);
-	// auto &cast_expr = (CastExpression &)*generated_expression;
+	// auto &cast_expr = generated_expression->Cast<CastExpression>();
 	// auto base_expr = std::move(cast_expr.child);
 	// generated_expression = make_uniq_base<ParsedExpression, CastExpression>(type, std::move(base_expr));
 }

package/src/duckdb/src/parser/expression/columnref_expression.cpp

@@ -69,9 +69,7 @@ bool ColumnRefExpression::Equal(const ColumnRefExpression *a, const ColumnRefExp
 		return false;
 	}
 	for (idx_t i = 0; i < a->column_names.size(); i++) {
-		auto lcase_a = StringUtil::Lower(a->column_names[i]);
-		auto lcase_b = StringUtil::Lower(b->column_names[i]);
-		if (lcase_a != lcase_b) {
+		if (!StringUtil::CIEquals(a->column_names[i], b->column_names[i])) {
 			return false;
 		}
 	}
@@ -81,8 +79,7 @@ bool ColumnRefExpression::Equal(const ColumnRefExpression *a, const ColumnRefExp
 hash_t ColumnRefExpression::Hash() const {
 	hash_t result = ParsedExpression::Hash();
 	for (auto &column_name : column_names) {
-		auto lcase = StringUtil::Lower(column_name);
-		result = CombineHash(result, duckdb::Hash<const char *>(lcase.c_str()));
+		result = CombineHash(result, StringUtil::CIHash(column_name));
 	}
 	return result;
 }

package/src/duckdb/src/parser/expression/conjunction_expression.cpp

@@ -29,7 +29,7 @@ ConjunctionExpression::ConjunctionExpression(ExpressionType type, unique_ptr<Par
 void ConjunctionExpression::AddExpression(unique_ptr<ParsedExpression> expr) {
 	if (expr->type == type) {
 		// expr is a conjunction of the same type: merge the expression lists together
-		auto &other = (ConjunctionExpression &)*expr;
+		auto &other = expr->Cast<ConjunctionExpression>();
 		for (auto &child : other.children) {
 			children.push_back(std::move(child));
 		}

package/src/duckdb/src/parser/expression/constant_expression.cpp

@@ -23,7 +23,7 @@ bool ConstantExpression::Equal(const ConstantExpression *a, const ConstantExpres
 }
 
 hash_t ConstantExpression::Hash() const {
-	return ParsedExpression::Hash();
+	return value.Hash();
 }
 
 unique_ptr<ParsedExpression> ConstantExpression::Copy() const {

package/src/duckdb/src/parser/parsed_data/create_view_info.cpp

@@ -85,7 +85,7 @@ unique_ptr<CreateViewInfo> CreateViewInfo::FromCreateView(ClientContext &context
 		    "Failed to create view from SQL string - \"%s\" - statement did not contain a single CREATE VIEW statement",
 		    sql);
 	}
-	auto &create_statement = (CreateStatement &)*parser.statements[0];
+	auto &create_statement = parser.statements[0]->Cast<CreateStatement>();
 	if (create_statement.info->type != CatalogType::VIEW_ENTRY) {
 		throw BinderException(
 		    "Failed to create view from SQL string - \"%s\" - view did not contain a CREATE VIEW statement", sql);

package/src/duckdb/src/parser/parsed_expression_iterator.cpp

@@ -29,14 +29,14 @@ void ParsedExpressionIterator::EnumerateChildren(
     ParsedExpression &expr, const std::function<void(unique_ptr<ParsedExpression> &child)> &callback) {
 	switch (expr.expression_class) {
 	case ExpressionClass::BETWEEN: {
-		auto &cast_expr = (BetweenExpression &)expr;
+		auto &cast_expr = expr.Cast<BetweenExpression>();
 		callback(cast_expr.input);
 		callback(cast_expr.lower);
 		callback(cast_expr.upper);
 		break;
 	}
 	case ExpressionClass::CASE: {
-		auto &case_expr = (CaseExpression &)expr;
+		auto &case_expr = expr.Cast<CaseExpression>();
 		for (auto &check : case_expr.case_checks) {
 			callback(check.when_expr);
 			callback(check.then_expr);
@@ -45,23 +45,23 @@ void ParsedExpressionIterator::EnumerateChildren(
 		break;
 	}
 	case ExpressionClass::CAST: {
-		auto &cast_expr = (CastExpression &)expr;
+		auto &cast_expr = expr.Cast<CastExpression>();
 		callback(cast_expr.child);
 		break;
 	}
 	case ExpressionClass::COLLATE: {
-		auto &cast_expr = (CollateExpression &)expr;
+		auto &cast_expr = expr.Cast<CollateExpression>();
 		callback(cast_expr.child);
 		break;
 	}
 	case ExpressionClass::COMPARISON: {
-		auto &comp_expr = (ComparisonExpression &)expr;
+		auto &comp_expr = expr.Cast<ComparisonExpression>();
 		callback(comp_expr.left);
 		callback(comp_expr.right);
 		break;
 	}
 	case ExpressionClass::CONJUNCTION: {
-		auto &conj_expr = (ConjunctionExpression &)expr;
+		auto &conj_expr = expr.Cast<ConjunctionExpression>();
 		for (auto &child : conj_expr.children) {
 			callback(child);
 		}
@@ -69,7 +69,7 @@ void ParsedExpressionIterator::EnumerateChildren(
 	}
 
 	case ExpressionClass::FUNCTION: {
-		auto &func_expr = (FunctionExpression &)expr;
+		auto &func_expr = expr.Cast<FunctionExpression>();
 		for (auto &child : func_expr.children) {
 			callback(child);
 		}
@@ -84,34 +84,34 @@ void ParsedExpressionIterator::EnumerateChildren(
 		break;
 	}
 	case ExpressionClass::LAMBDA: {
-		auto &lambda_expr = (LambdaExpression &)expr;
+		auto &lambda_expr = expr.Cast<LambdaExpression>();
 		callback(lambda_expr.lhs);
 		callback(lambda_expr.expr);
 		break;
 	}
 	case ExpressionClass::OPERATOR: {
-		auto &op_expr = (OperatorExpression &)expr;
+		auto &op_expr = expr.Cast<OperatorExpression>();
 		for (auto &child : op_expr.children) {
 			callback(child);
 		}
 		break;
 	}
 	case ExpressionClass::STAR: {
-		auto &star_expr = (StarExpression &)expr;
+		auto &star_expr = expr.Cast<StarExpression>();
 		if (star_expr.expr) {
 			callback(star_expr.expr);
 		}
 		break;
 	}
 	case ExpressionClass::SUBQUERY: {
-		auto &subquery_expr = (SubqueryExpression &)expr;
+		auto &subquery_expr = expr.Cast<SubqueryExpression>();
 		if (subquery_expr.child) {
 			callback(subquery_expr.child);
 		}
 		break;
 	}
 	case ExpressionClass::WINDOW: {
-		auto &window_expr = (WindowExpression &)expr;
+		auto &window_expr = expr.Cast<WindowExpression>();
 		for (auto &partition : window_expr.partitions) {
 			callback(partition);
 		}
@@ -202,7 +202,7 @@ void ParsedExpressionIterator::EnumerateTableRefChildren(
     TableRef &ref, const std::function<void(unique_ptr<ParsedExpression> &child)> &callback) {
 	switch (ref.type) {
 	case TableReferenceType::EXPRESSION_LIST: {
-		auto &el_ref = (ExpressionListRef &)ref;
+		auto &el_ref = ref.Cast<ExpressionListRef>();
 		for (idx_t i = 0; i < el_ref.values.size(); i++) {
 			for (idx_t j = 0; j < el_ref.values[i].size(); j++) {
 				callback(el_ref.values[i][j]);
@@ -211,7 +211,7 @@ void ParsedExpressionIterator::EnumerateTableRefChildren(
 		break;
 	}
 	case TableReferenceType::JOIN: {
-		auto &j_ref = (JoinRef &)ref;
+		auto &j_ref = ref.Cast<JoinRef>();
 		EnumerateTableRefChildren(*j_ref.left, callback);
 		EnumerateTableRefChildren(*j_ref.right, callback);
 		if (j_ref.condition) {
@@ -220,7 +220,7 @@ void ParsedExpressionIterator::EnumerateTableRefChildren(
 		break;
 	}
 	case TableReferenceType::PIVOT: {
-		auto &p_ref = (PivotRef &)ref;
+		auto &p_ref = ref.Cast<PivotRef>();
 		EnumerateTableRefChildren(*p_ref.source, callback);
 		for (auto &aggr : p_ref.aggregates) {
 			callback(aggr);
@@ -228,12 +228,12 @@ void ParsedExpressionIterator::EnumerateTableRefChildren(
 		break;
 	}
 	case TableReferenceType::SUBQUERY: {
-		auto &sq_ref = (SubqueryRef &)ref;
+		auto &sq_ref = ref.Cast<SubqueryRef>();
 		EnumerateQueryNodeChildren(*sq_ref.subquery->node, callback);
 		break;
 	}
 	case TableReferenceType::TABLE_FUNCTION: {
-		auto &tf_ref = (TableFunctionRef &)ref;
+		auto &tf_ref = ref.Cast<TableFunctionRef>();
 		callback(tf_ref.function);
 		break;
 	}
@@ -251,13 +251,13 @@ void ParsedExpressionIterator::EnumerateQueryNodeChildren(
     QueryNode &node, const std::function<void(unique_ptr<ParsedExpression> &child)> &callback) {
 	switch (node.type) {
 	case QueryNodeType::RECURSIVE_CTE_NODE: {
-		auto &rcte_node = (RecursiveCTENode &)node;
+		auto &rcte_node = node.Cast<RecursiveCTENode>();
 		EnumerateQueryNodeChildren(*rcte_node.left, callback);
 		EnumerateQueryNodeChildren(*rcte_node.right, callback);
 		break;
 	}
 	case QueryNodeType::SELECT_NODE: {
-		auto &sel_node = (SelectNode &)node;
+		auto &sel_node = node.Cast<SelectNode>();
 		for (idx_t i = 0; i < sel_node.select_list.size(); i++) {
 			callback(sel_node.select_list[i]);
 		}
@@ -278,7 +278,7 @@ void ParsedExpressionIterator::EnumerateQueryNodeChildren(
 		break;
 	}
 	case QueryNodeType::SET_OPERATION_NODE: {
-		auto &setop_node = (SetOperationNode &)node;
+		auto &setop_node = node.Cast<SetOperationNode>();
 		EnumerateQueryNodeChildren(*setop_node.left, callback);
 		EnumerateQueryNodeChildren(*setop_node.right, callback);
 		break;

package/src/duckdb/src/parser/parser.cpp

@@ -178,7 +178,7 @@ void Parser::ParseQuery(const string &query) {
 		for (auto &statement : statements) {
 			statement->query = query;
 			if (statement->type == StatementType::CREATE_STATEMENT) {
-				auto &create = (CreateStatement &)*statement;
+				auto &create = statement->Cast<CreateStatement>();
 				create.info->sql = query.substr(statement->stmt_location, statement->stmt_length);
 			}
 		}
@@ -261,11 +261,11 @@ vector<unique_ptr<ParsedExpression>> Parser::ParseExpressionList(const string &s
 	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
 		throw ParserException("Expected a single SELECT statement");
 	}
-	auto &select = (SelectStatement &)*parser.statements[0];
+	auto &select = parser.statements[0]->Cast<SelectStatement>();
 	if (select.node->type != QueryNodeType::SELECT_NODE) {
 		throw ParserException("Expected a single SELECT node");
 	}
-	auto &select_node = (SelectNode &)*select.node;
+	auto &select_node = select.node->Cast<SelectNode>();
 	return std::move(select_node.select_list);
 }
 
@@ -279,11 +279,11 @@ vector<OrderByNode> Parser::ParseOrderList(const string &select_list, ParserOpti
 	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
 		throw ParserException("Expected a single SELECT statement");
 	}
-	auto &select = (SelectStatement &)*parser.statements[0];
+	auto &select = parser.statements[0]->Cast<SelectStatement>();
 	if (select.node->type != QueryNodeType::SELECT_NODE) {
 		throw ParserException("Expected a single SELECT node");
 	}
-	auto &select_node = (SelectNode &)*select.node;
+	auto &select_node = select.node->Cast<SelectNode>();
 	if (select_node.modifiers.empty() || select_node.modifiers[0]->type != ResultModifierType::ORDER_MODIFIER ||
 	    select_node.modifiers.size() != 1) {
 		throw ParserException("Expected a single ORDER clause");
@@ -303,7 +303,7 @@ void Parser::ParseUpdateList(const string &update_list, vector<string> &update_c
 	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::UPDATE_STATEMENT) {
 		throw ParserException("Expected a single UPDATE statement");
 	}
-	auto &update = (UpdateStatement &)*parser.statements[0];
+	auto &update = parser.statements[0]->Cast<UpdateStatement>();
 	update_columns = std::move(update.set_info->columns);
 	expressions = std::move(update.set_info->expressions);
 }
@@ -318,15 +318,15 @@ vector<vector<unique_ptr<ParsedExpression>>> Parser::ParseValuesList(const strin
 	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
 		throw ParserException("Expected a single SELECT statement");
 	}
-	auto &select = (SelectStatement &)*parser.statements[0];
+	auto &select = parser.statements[0]->Cast<SelectStatement>();
 	if (select.node->type != QueryNodeType::SELECT_NODE) {
 		throw ParserException("Expected a single SELECT node");
 	}
-	auto &select_node = (SelectNode &)*select.node;
+	auto &select_node = select.node->Cast<SelectNode>();
 	if (!select_node.from_table || select_node.from_table->type != TableReferenceType::EXPRESSION_LIST) {
 		throw ParserException("Expected a single VALUES statement");
 	}
-	auto &values_list = (ExpressionListRef &)*select_node.from_table;
+	auto &values_list = select_node.from_table->Cast<ExpressionListRef>();
 	return std::move(values_list.values);
 }
 
@@ -337,7 +337,7 @@ ColumnList Parser::ParseColumnList(const string &column_list, ParserOptions opti
 	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::CREATE_STATEMENT) {
 		throw ParserException("Expected a single CREATE statement");
 	}
-	auto &create = (CreateStatement &)*parser.statements[0];
+	auto &create = parser.statements[0]->Cast<CreateStatement>();
 	if (create.info->type != CatalogType::TABLE_ENTRY) {
 		throw InternalException("Expected a single CREATE TABLE statement");
 	}

package/src/duckdb/src/parser/query_node/recursive_cte_node.cpp

@@ -23,15 +23,15 @@ bool RecursiveCTENode::Equals(const QueryNode *other_p) const {
 	if (this == other_p) {
 		return true;
 	}
-	auto other = (RecursiveCTENode *)other_p;
+	auto &other = other_p->Cast<RecursiveCTENode>();
 
-	if (other->union_all != union_all) {
+	if (other.union_all != union_all) {
 		return false;
 	}
-	if (!left->Equals(other->left.get())) {
+	if (!left->Equals(other.left.get())) {
 		return false;
 	}
-	if (!right->Equals(other->right.get())) {
+	if (!right->Equals(other.right.get())) {
 		return false;
 	}
 	return true;