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

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

@@ -115,6 +115,8 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 		case ResultModifierType::DISTINCT_MODIFIER: {
 			auto &distinct = (DistinctModifier &)*mod;
 			auto bound_distinct = make_uniq<BoundDistinctModifier>();
+			bound_distinct->distinct_type =
+			    distinct.distinct_on_targets.empty() ? DistinctType::DISTINCT : DistinctType::DISTINCT_ON;
 			if (distinct.distinct_on_targets.empty()) {
 				for (idx_t i = 0; i < result.names.size(); i++) {
 					distinct.distinct_on_targets.push_back(make_uniq<ConstantExpression>(Value::INTEGER(1 + i)));
@@ -137,8 +139,8 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 			D_ASSERT(!order.orders.empty());
 			auto &order_binders = order_binder.GetBinders();
 			if (order.orders.size() == 1 && order.orders[0].expression->type == ExpressionType::STAR) {
-				auto star = (StarExpression *)order.orders[0].expression.get();
-				if (star->exclude_list.empty() && star->replace_list.empty() && !star->expr) {
+				auto &star = order.orders[0].expression->Cast<StarExpression>();
+				if (star.exclude_list.empty() && star.replace_list.empty() && !star.expr) {
 					// ORDER BY ALL
 					// replace the order list with the all elements in the SELECT list
 					auto order_type = order.orders[0].type;
@@ -189,15 +191,14 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 	}
 }
 
-static void AssignReturnType(unique_ptr<Expression> &expr, const vector<LogicalType> &sql_types,
-                             idx_t projection_index) {
+static void AssignReturnType(unique_ptr<Expression> &expr, const vector<LogicalType> &sql_types) {
 	if (!expr) {
 		return;
 	}
 	if (expr->type != ExpressionType::BOUND_COLUMN_REF) {
 		return;
 	}
-	auto &bound_colref = (BoundColumnRefExpression &)*expr;
+	auto &bound_colref = expr->Cast<BoundColumnRefExpression>();
 	bound_colref.return_type = sql_types[bound_colref.binding.column_index];
 }
 
@@ -206,26 +207,19 @@ void Binder::BindModifierTypes(BoundQueryNode &result, const vector<LogicalType>
 		switch (bound_mod->type) {
 		case ResultModifierType::DISTINCT_MODIFIER: {
 			auto &distinct = (BoundDistinctModifier &)*bound_mod;
-			if (distinct.target_distincts.empty()) {
-				// DISTINCT without a target: push references to the standard select list
-				for (idx_t i = 0; i < sql_types.size(); i++) {
-					distinct.target_distincts.push_back(
-					    make_uniq<BoundColumnRefExpression>(sql_types[i], ColumnBinding(projection_index, i)));
-				}
-			} else {
-				// DISTINCT with target list: set types
-				for (auto &expr : distinct.target_distincts) {
-					D_ASSERT(expr->type == ExpressionType::BOUND_COLUMN_REF);
-					auto &bound_colref = (BoundColumnRefExpression &)*expr;
-					if (bound_colref.binding.column_index == DConstants::INVALID_INDEX) {
-						throw BinderException("Ambiguous name in DISTINCT ON!");
-					}
-					D_ASSERT(bound_colref.binding.column_index < sql_types.size());
-					bound_colref.return_type = sql_types[bound_colref.binding.column_index];
+			D_ASSERT(!distinct.target_distincts.empty());
+			// set types of distinct targets
+			for (auto &expr : distinct.target_distincts) {
+				D_ASSERT(expr->type == ExpressionType::BOUND_COLUMN_REF);
+				auto &bound_colref = expr->Cast<BoundColumnRefExpression>();
+				if (bound_colref.binding.column_index == DConstants::INVALID_INDEX) {
+					throw BinderException("Ambiguous name in DISTINCT ON!");
 				}
+				D_ASSERT(bound_colref.binding.column_index < sql_types.size());
+				bound_colref.return_type = sql_types[bound_colref.binding.column_index];
 			}
 			for (auto &target_distinct : distinct.target_distincts) {
-				auto &bound_colref = (BoundColumnRefExpression &)*target_distinct;
+				auto &bound_colref = target_distinct->Cast<BoundColumnRefExpression>();
 				const auto &sql_type = sql_types[bound_colref.binding.column_index];
 				if (sql_type.id() == LogicalTypeId::VARCHAR) {
 					target_distinct = ExpressionBinder::PushCollation(context, std::move(target_distinct),
@@ -236,14 +230,14 @@ void Binder::BindModifierTypes(BoundQueryNode &result, const vector<LogicalType>
 		}
 		case ResultModifierType::LIMIT_MODIFIER: {
 			auto &limit = (BoundLimitModifier &)*bound_mod;
-			AssignReturnType(limit.limit, sql_types, projection_index);
-			AssignReturnType(limit.offset, sql_types, projection_index);
+			AssignReturnType(limit.limit, sql_types);
+			AssignReturnType(limit.offset, sql_types);
 			break;
 		}
 		case ResultModifierType::LIMIT_PERCENT_MODIFIER: {
 			auto &limit = (BoundLimitPercentModifier &)*bound_mod;
-			AssignReturnType(limit.limit, sql_types, projection_index);
-			AssignReturnType(limit.offset, sql_types, projection_index);
+			AssignReturnType(limit.limit, sql_types);
+			AssignReturnType(limit.offset, sql_types);
 			break;
 		}
 		case ResultModifierType::ORDER_MODIFIER: {
@@ -251,7 +245,7 @@ void Binder::BindModifierTypes(BoundQueryNode &result, const vector<LogicalType>
 			for (auto &order_node : order.orders) {
 				auto &expr = order_node.expression;
 				D_ASSERT(expr->type == ExpressionType::BOUND_COLUMN_REF);
-				auto &bound_colref = (BoundColumnRefExpression &)*expr;
+				auto &bound_colref = expr->Cast<BoundColumnRefExpression>();
 				if (bound_colref.binding.column_index == DConstants::INVALID_INDEX) {
 					throw BinderException("Ambiguous name in ORDER BY!");
 				}
@@ -282,14 +276,14 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 void Binder::BindWhereStarExpression(unique_ptr<ParsedExpression> &expr) {
 	// expand any expressions in the upper AND recursively
 	if (expr->type == ExpressionType::CONJUNCTION_AND) {
-		auto &conj = (ConjunctionExpression &)*expr;
+		auto &conj = expr->Cast<ConjunctionExpression>();
 		for (auto &child : conj.children) {
 			BindWhereStarExpression(child);
 		}
 		return;
 	}
 	if (expr->type == ExpressionType::STAR) {
-		auto &star = (StarExpression &)*expr;
+		auto &star = expr->Cast<StarExpression>();
 		if (!star.columns) {
 			throw ParserException("STAR expression is not allowed in the WHERE clause. Use COLUMNS(*) instead.");
 		}

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

@@ -16,7 +16,7 @@ static void GatherAliases(BoundQueryNode &node, case_insensitive_map_t<idx_t> &a
                           expression_map_t<idx_t> &expressions, const vector<idx_t> &reorder_idx) {
 	if (node.type == QueryNodeType::SET_OPERATION_NODE) {
 		// setop, recurse
-		auto &setop = (BoundSetOperationNode &)node;
+		auto &setop = node.Cast<BoundSetOperationNode>();
 
 		// create new reorder index
 		if (setop.setop_type == SetOperationType::UNION_BY_NAME) {
@@ -41,7 +41,7 @@ static void GatherAliases(BoundQueryNode &node, case_insensitive_map_t<idx_t> &a
 	} else {
 		// query node
 		D_ASSERT(node.type == QueryNodeType::SELECT_NODE);
-		auto &select = (BoundSelectNode &)node;
+		auto &select = node.Cast<BoundSelectNode>();
 		// fill the alias lists
 		for (idx_t i = 0; i < select.names.size(); i++) {
 			auto &name = select.names[i];

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

@@ -41,7 +41,7 @@ unique_ptr<QueryNode> Binder::BindTableMacro(FunctionExpression &function, Table
 	// positional parameters
 	for (idx_t i = 0; i < macro_def.parameters.size(); i++) {
 		types.emplace_back(LogicalType::SQLNULL);
-		auto &param = (ColumnRefExpression &)*macro_def.parameters[i];
+		auto &param = macro_def.parameters[i]->Cast<ColumnRefExpression>();
 		names.push_back(param.GetColumnName());
 	}
 	// default parameters

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

@@ -14,7 +14,7 @@ unique_ptr<LogicalOperator> Binder::VisitQueryNode(BoundQueryNode &node, unique_
 		switch (mod->type) {
 		case ResultModifierType::DISTINCT_MODIFIER: {
 			auto &bound = (BoundDistinctModifier &)*mod;
-			auto distinct = make_uniq<LogicalDistinct>(std::move(bound.target_distincts));
+			auto distinct = make_uniq<LogicalDistinct>(std::move(bound.target_distincts), bound.distinct_type);
 			distinct->AddChild(std::move(root));
 			root = std::move(distinct);
 			break;
@@ -22,8 +22,8 @@ unique_ptr<LogicalOperator> Binder::VisitQueryNode(BoundQueryNode &node, unique_
 		case ResultModifierType::ORDER_MODIFIER: {
 			auto &bound = (BoundOrderModifier &)*mod;
 			if (root->type == LogicalOperatorType::LOGICAL_DISTINCT) {
-				auto &distinct = (LogicalDistinct &)*root;
-				if (!distinct.distinct_targets.empty()) {
+				auto &distinct = root->Cast<LogicalDistinct>();
+				if (distinct.distinct_type == DistinctType::DISTINCT_ON) {
 					auto order_by = make_uniq<BoundOrderModifier>();
 					for (auto &order_node : bound.orders) {
 						order_by->orders.push_back(order_node.Copy());

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

@@ -30,9 +30,8 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundRecursiveCTENode &node) {
 		                                           std::move(right_node), LogicalOperatorType::LOGICAL_UNION);
 		return VisitQueryNode(node, std::move(root));
 	}
-	auto root =
-	    make_uniq<LogicalRecursiveCTE>(node.setop_index, node.types.size(), node.union_all, std::move(left_node),
-	                                   std::move(right_node), LogicalOperatorType::LOGICAL_RECURSIVE_CTE);
+	auto root = make_uniq<LogicalRecursiveCTE>(node.setop_index, node.types.size(), node.union_all,
+	                                           std::move(left_node), std::move(right_node));
 
 	return VisitQueryNode(node, std::move(root));
 }

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

@@ -3,9 +3,7 @@
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "duckdb/planner/operator/list.hpp"
 #include "duckdb/planner/operator/logical_dummy_scan.hpp"
-#include "duckdb/planner/operator/logical_expression_get.hpp"
 #include "duckdb/planner/operator/logical_limit.hpp"
-#include "duckdb/planner/operator/logical_limit_percent.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
 
 namespace duckdb {

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

@@ -389,7 +389,7 @@ void Binder::PlanSubqueries(unique_ptr<Expression> *expr_ptr, unique_ptr<Logical
 
 	// check if this is a subquery node
 	if (expr.expression_class == ExpressionClass::BOUND_SUBQUERY) {
-		auto &subquery = (BoundSubqueryExpression &)expr;
+		auto &subquery = expr.Cast<BoundSubqueryExpression>();
 		// subquery node! plan it
 		if (subquery.IsCorrelated() && !plan_subquery) {
 			// detected a nested correlated subquery

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

@@ -13,8 +13,9 @@ BoundStatement Binder::Bind(CallStatement &stmt) {
 	ref.function = std::move(stmt.function);
 
 	auto bound_func = Bind(ref);
-	auto &bound_table_func = (BoundTableFunction &)*bound_func;
-	auto &get = (LogicalGet &)*bound_table_func.get;
+	auto &bound_table_func = bound_func->Cast<BoundTableFunction>();
+	;
+	auto &get = bound_table_func.get->Cast<LogicalGet>();
 	D_ASSERT(get.returned_types.size() > 0);
 	for (idx_t i = 0; i < get.returned_types.size(); i++) {
 		get.column_ids.push_back(i);

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

@@ -173,7 +173,7 @@ BoundStatement Binder::BindCopyFrom(CopyStatement &stmt) {
 	auto insert_statement = Bind(insert);
 	D_ASSERT(insert_statement.plan->type == LogicalOperatorType::LOGICAL_INSERT);
 
-	auto &bound_insert = (LogicalInsert &)*insert_statement.plan;
+	auto &bound_insert = insert_statement.plan->Cast<LogicalInsert>();
 
 	// lookup the format in the catalog
 	auto &catalog = Catalog::GetSystemCatalog(context);

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

@@ -135,7 +135,7 @@ void Binder::BindCreateViewInfo(CreateViewInfo &base) {
 static void QualifyFunctionNames(ClientContext &context, unique_ptr<ParsedExpression> &expr) {
 	switch (expr->GetExpressionClass()) {
 	case ExpressionClass::FUNCTION: {
-		auto &func = (FunctionExpression &)*expr;
+		auto &func = expr->Cast<FunctionExpression>();
 		auto function = (StandardEntry *)Catalog::GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, func.catalog,
 		                                                   func.schema, func.function_name, true);
 		if (function) {
@@ -146,7 +146,7 @@ static void QualifyFunctionNames(ClientContext &context, unique_ptr<ParsedExpres
 	}
 	case ExpressionClass::SUBQUERY: {
 		// replacing parameters within a subquery is slightly different
-		auto &sq = ((SubqueryExpression &)*expr).subquery;
+		auto &sq = (expr->Cast<SubqueryExpression>()).subquery;
 		ParsedExpressionIterator::EnumerateQueryNodeChildren(
 		    *sq->node, [&](unique_ptr<ParsedExpression> &child) { QualifyFunctionNames(context, child); });
 		break;
@@ -172,7 +172,7 @@ SchemaCatalogEntry *Binder::BindCreateFunctionInfo(CreateInfo &info) {
 	vector<string> dummy_names;
 	// positional parameters
 	for (idx_t i = 0; i < base.function->parameters.size(); i++) {
-		auto param = (ColumnRefExpression &)*base.function->parameters[i];
+		auto param = base.function->parameters[i]->Cast<ColumnRefExpression>();
 		if (param.IsQualified()) {
 			throw BinderException("Invalid parameter name '%s': must be unqualified", param.ToString());
 		}
@@ -181,7 +181,7 @@ SchemaCatalogEntry *Binder::BindCreateFunctionInfo(CreateInfo &info) {
 	}
 	// default parameters
 	for (auto it = base.function->default_parameters.begin(); it != base.function->default_parameters.end(); it++) {
-		auto &val = (ConstantExpression &)*it->second;
+		auto &val = it->second->Cast<ConstantExpression>();
 		dummy_types.push_back(val.value.type());
 		dummy_names.push_back(it->first);
 	}
@@ -278,7 +278,7 @@ static void FindMatchingPrimaryKeyColumns(const ColumnList &columns, const vecto
 		if (constr->type != ConstraintType::UNIQUE) {
 			continue;
 		}
-		auto &unique = (UniqueConstraint &)*constr;
+		auto &unique = constr->Cast<UniqueConstraint>();
 		if (find_primary_key && !unique.is_primary_key) {
 			continue;
 		}
@@ -364,7 +364,7 @@ void ExpressionContainsGeneratedColumn(const ParsedExpression &expr, const unord
 		return;
 	}
 	if (expr.type == ExpressionType::COLUMN_REF) {
-		auto &column_ref = (ColumnRefExpression &)expr;
+		auto &column_ref = expr.Cast<ColumnRefExpression>();
 		auto &name = column_ref.GetColumnName();
 		if (gcols.count(name)) {
 			contains_gcol = true;
@@ -390,7 +390,7 @@ static bool AnyConstraintReferencesGeneratedColumn(CreateTableInfo &table_info)
 	for (auto &constr : table_info.constraints) {
 		switch (constr->type) {
 		case ConstraintType::CHECK: {
-			auto &constraint = (CheckConstraint &)*constr;
+			auto &constraint = constr->Cast<CheckConstraint>();
 			auto &expr = constraint.expression;
 			bool contains_generated_column = false;
 			ExpressionContainsGeneratedColumn(*expr, generated_columns, contains_generated_column);
@@ -400,14 +400,14 @@ static bool AnyConstraintReferencesGeneratedColumn(CreateTableInfo &table_info)
 			break;
 		}
 		case ConstraintType::NOT_NULL: {
-			auto &constraint = (NotNullConstraint &)*constr;
+			auto &constraint = constr->Cast<NotNullConstraint>();
 			if (table_info.columns.GetColumn(constraint.index).Generated()) {
 				return true;
 			}
 			break;
 		}
 		case ConstraintType::UNIQUE: {
-			auto &constraint = (UniqueConstraint &)*constr;
+			auto &constraint = constr->Cast<UniqueConstraint>();
 			auto index = constraint.index;
 			if (index.index == DConstants::INVALID_INDEX) {
 				for (auto &col : constraint.columns) {
@@ -439,7 +439,7 @@ unique_ptr<LogicalOperator> DuckCatalog::BindCreateIndex(Binder &binder, CreateS
 	D_ASSERT(plan->type == LogicalOperatorType::LOGICAL_GET);
 	auto &base = (CreateIndexInfo &)*stmt.info;
 
-	auto &get = (LogicalGet &)*plan;
+	auto &get = plan->Cast<LogicalGet>();
 	// bind the index expressions
 	IndexBinder index_binder(binder, binder.context);
 	vector<unique_ptr<Expression>> expressions;
@@ -506,7 +506,8 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 		if (bound_table->type != TableReferenceType::BASE_TABLE) {
 			throw BinderException("Can only create an index over a base table!");
 		}
-		auto &table_binding = (BoundBaseTableRef &)*bound_table;
+		auto &table_binding = bound_table->Cast<BoundBaseTableRef>();
+		;
 		auto table = table_binding.table;
 		if (table->temporary) {
 			stmt.info->temporary = true;
@@ -529,7 +530,7 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 			if (cond->type != ConstraintType::FOREIGN_KEY) {
 				continue;
 			}
-			auto &fk = (ForeignKeyConstraint &)*cond;
+			auto &fk = cond->Cast<ForeignKeyConstraint>();
 			if (fk.info.type != ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
 				continue;
 			}
@@ -593,7 +594,7 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 		result.plan = make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_TYPE, std::move(stmt.info), schema);
 		if (create_type_info.query) {
 			// CREATE TYPE mood AS ENUM (SELECT 'happy')
-			auto &select_stmt = (SelectStatement &)*create_type_info.query;
+			auto &select_stmt = create_type_info.query->Cast<SelectStatement>();
 			auto &query_node = *select_stmt.node;
 
 			// We always add distinct modifier implicitly
@@ -605,15 +606,15 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 					// When we push into a constant expression
 					// => CREATE TYPE mood AS ENUM (SELECT DISTINCT ON(x, x) x FROM test);
 					auto &distinct_modifier = (DistinctModifier &)*query_node.modifiers[0];
-					distinct_modifier.distinct_on_targets.push_back(make_uniq<ConstantExpression>(Value::INTEGER(1)));
-					need_to_add = false;
+					if (distinct_modifier.distinct_on_targets.empty()) {
+						need_to_add = false;
+					}
 				}
 			}
 
 			// Add distinct modifier
 			if (need_to_add) {
 				auto distinct_modifier = make_uniq<DistinctModifier>();
-				distinct_modifier->distinct_on_targets.push_back(make_uniq<ConstantExpression>(Value::INTEGER(1)));
 				query_node.modifiers.emplace(query_node.modifiers.begin(), std::move(distinct_modifier));
 			}
 

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

@@ -40,7 +40,8 @@ static void BindCheckConstraint(Binder &binder, BoundCreateTableInfo &info, cons
 	auto bound_constraint = make_uniq<BoundCheckConstraint>();
 	// check constraint: bind the expression
 	CheckBinder check_binder(binder, binder.context, base.table, base.columns, bound_constraint->bound_columns);
-	auto &check = (CheckConstraint &)*cond;
+	auto &check = cond->Cast<CheckConstraint>();
+	;
 	// create a copy of the unbound expression because the binding destroys the constraint
 	auto unbound_expression = check.expression->Copy();
 	// now bind the constraint and create a new BoundCheckConstraint
@@ -64,14 +65,14 @@ static void BindConstraints(Binder &binder, BoundCreateTableInfo &info) {
 			break;
 		}
 		case ConstraintType::NOT_NULL: {
-			auto &not_null = (NotNullConstraint &)*cond;
+			auto &not_null = cond->Cast<NotNullConstraint>();
 			auto &col = base.columns.GetColumn(LogicalIndex(not_null.index));
 			info.bound_constraints.push_back(make_uniq<BoundNotNullConstraint>(PhysicalIndex(col.StorageOid())));
 			not_null_columns.insert(not_null.index);
 			break;
 		}
 		case ConstraintType::UNIQUE: {
-			auto &unique = (UniqueConstraint &)*cond;
+			auto &unique = cond->Cast<UniqueConstraint>();
 			// have to resolve columns of the unique constraint
 			vector<LogicalIndex> keys;
 			logical_index_set_t key_set;
@@ -114,7 +115,7 @@ static void BindConstraints(Binder &binder, BoundCreateTableInfo &info) {
 			break;
 		}
 		case ConstraintType::FOREIGN_KEY: {
-			auto &fk = (ForeignKeyConstraint &)*cond;
+			auto &fk = cond->Cast<ForeignKeyConstraint>();
 			D_ASSERT((fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE && !fk.info.pk_keys.empty()) ||
 			         (fk.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE && !fk.info.pk_keys.empty()) ||
 			         fk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE);
@@ -228,7 +229,7 @@ void Binder::BindDefaultValues(const ColumnList &columns, vector<unique_ptr<Expr
 
 static void ExtractExpressionDependencies(Expression &expr, DependencyList &dependencies) {
 	if (expr.type == ExpressionType::BOUND_FUNCTION) {
-		auto &function = (BoundFunctionExpression &)expr;
+		auto &function = expr.Cast<BoundFunctionExpression>();
 		if (function.function.dependency) {
 			function.function.dependency(function, dependencies);
 		}
@@ -245,7 +246,7 @@ static void ExtractDependencies(BoundCreateTableInfo &info) {
 	}
 	for (auto &constraint : info.bound_constraints) {
 		if (constraint->type == ConstraintType::CHECK) {
-			auto &bound_check = (BoundCheckConstraint &)*constraint;
+			auto &bound_check = constraint->Cast<BoundCheckConstraint>();
 			ExtractExpressionDependencies(*bound_check.expression, info.dependencies);
 		}
 	}

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

@@ -20,11 +20,12 @@ BoundStatement Binder::Bind(DeleteStatement &stmt) {
 	if (bound_table->type != TableReferenceType::BASE_TABLE) {
 		throw BinderException("Can only delete from base table!");
 	}
-	auto &table_binding = (BoundBaseTableRef &)*bound_table;
+	auto &table_binding = bound_table->Cast<BoundBaseTableRef>();
+	;
 	auto table = table_binding.table;
 
 	auto root = CreatePlan(*bound_table);
-	auto &get = (LogicalGet &)*root;
+	auto &get = root->Cast<LogicalGet>();
 	D_ASSERT(root->type == LogicalOperatorType::LOGICAL_GET);
 
 	if (!table->temporary) {

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

@@ -59,7 +59,7 @@ void ScanForeignKeyTable(vector<TableCatalogEntry *> &ordered, vector<TableCatal
 		for (idx_t j = 0; j < constraints.size(); j++) {
 			auto &cond = constraints[j];
 			if (cond->type == ConstraintType::FOREIGN_KEY) {
-				auto &fk = (ForeignKeyConstraint &)*cond;
+				auto &fk = cond->Cast<ForeignKeyConstraint>();
 				if ((move_only_pk_table && fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) ||
 				    (!move_only_pk_table && fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE &&
 				     IsExistMainKeyTable(fk.info.table, unordered))) {

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

@@ -19,7 +19,7 @@ BoundStatement Binder::Bind(ExtensionStatement &stmt) {
 	// create the plan as a scan of the given table function
 	result.plan = BindTableFunction(parse_result.function, std::move(parse_result.parameters));
 	D_ASSERT(result.plan->type == LogicalOperatorType::LOGICAL_GET);
-	auto &get = (LogicalGet &)*result.plan;
+	auto &get = result.plan->Cast<LogicalGet>();
 	result.names = get.names;
 	result.types = get.returned_types;
 	get.column_ids.clear();

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

@@ -54,7 +54,7 @@ void ReplaceDefaultExpression(unique_ptr<ParsedExpression> &expr, const ColumnDe
 void QualifyColumnReferences(unique_ptr<ParsedExpression> &expr, const string &table_name) {
 	// To avoid ambiguity with 'excluded', we explicitly qualify all column references
 	if (expr->type == ExpressionType::COLUMN_REF) {
-		auto &column_ref = (ColumnRefExpression &)*expr;
+		auto &column_ref = expr->Cast<ColumnRefExpression>();
 		if (column_ref.IsQualified()) {
 			return;
 		}
@@ -68,7 +68,7 @@ void QualifyColumnReferences(unique_ptr<ParsedExpression> &expr, const string &t
 // Replace binding.table_index with 'dest' if it's 'source'
 void ReplaceColumnBindings(Expression &expr, idx_t source, idx_t dest) {
 	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &bound_columnref = (BoundColumnRefExpression &)expr;
+		auto &bound_columnref = expr.Cast<BoundColumnRefExpression>();
 		if (bound_columnref.binding.table_index == source) {
 			bound_columnref.binding.table_index = dest;
 		}
@@ -200,7 +200,7 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 		throw BinderException("Can only update base table!");
 	}
 
-	auto &table_ref = (BaseTableRef &)*stmt.table_ref;
+	auto &table_ref = stmt.table_ref->Cast<BaseTableRef>();
 	const string &table_alias = !table_ref.alias.empty() ? table_ref.alias : table_ref.table_name;
 
 	auto &on_conflict = *stmt.on_conflict_info;
@@ -460,7 +460,7 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 	// special case: check if we are inserting from a VALUES statement
 	auto values_list = stmt.GetValuesList();
 	if (values_list) {
-		auto &expr_list = (ExpressionListRef &)*values_list;
+		auto &expr_list = values_list->Cast<ExpressionListRef>();
 		expr_list.expected_types.resize(expected_columns);
 		expr_list.expected_names.resize(expected_columns);
 

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

@@ -29,11 +29,11 @@ BoundStatement Binder::Bind(ResetVariableStatement &stmt) {
 BoundStatement Binder::Bind(SetStatement &stmt) {
 	switch (stmt.set_type) {
 	case SetType::SET: {
-		auto &set_stmt = (SetVariableStatement &)stmt;
+		auto &set_stmt = stmt.Cast<SetVariableStatement>();
 		return Bind(set_stmt);
 	}
 	case SetType::RESET: {
-		auto &set_stmt = (ResetVariableStatement &)stmt;
+		auto &set_stmt = stmt.Cast<ResetVariableStatement>();
 		return Bind(set_stmt);
 	}
 	default:

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

@@ -188,7 +188,8 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 	if (bound_table->type != TableReferenceType::BASE_TABLE) {
 		throw BinderException("Can only update base table!");
 	}
-	auto &table_binding = (BoundBaseTableRef &)*bound_table;
+	auto &table_binding = bound_table->Cast<BoundBaseTableRef>();
+	;
 	auto table = table_binding.table;
 
 	// Add CTEs as bindable

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

@@ -27,7 +27,7 @@ BoundStatement Binder::Bind(VacuumStatement &stmt) {
 		vector<unique_ptr<Expression>> select_list;
 		if (columns.empty()) {
 			// Empty means ALL columns should be vacuumed/analyzed
-			auto &get = (LogicalGet &)*ref->get;
+			auto &get = ref->get->Cast<LogicalGet>();
 			columns.insert(columns.end(), get.names.begin(), get.names.end());
 		}
 
@@ -59,7 +59,7 @@ BoundStatement Binder::Bind(VacuumStatement &stmt) {
 			auto table_scan = CreatePlan(*ref);
 			D_ASSERT(table_scan->type == LogicalOperatorType::LOGICAL_GET);
 
-			auto &get = (LogicalGet &)*table_scan;
+			auto &get = table_scan->Cast<LogicalGet>();
 
 			D_ASSERT(select_list.size() == get.column_ids.size());
 			D_ASSERT(stmt.info->columns.size() == get.column_ids.size());

package/src/duckdb/src/planner/binder/tableref/bind_basetableref.cpp

@@ -80,11 +80,11 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 				if (replacement_function) {
 					replacement_function->alias = ref.alias.empty() ? ref.table_name : ref.alias;
 					if (replacement_function->type == TableReferenceType::TABLE_FUNCTION) {
-						auto &table_function = (TableFunctionRef &)*replacement_function;
+						auto &table_function = replacement_function->Cast<TableFunctionRef>();
 						table_function.column_name_alias = ref.column_name_alias;
 						;
 					} else if (replacement_function->type == TableReferenceType::SUBQUERY) {
-						auto &subquery = (SubqueryRef &)*replacement_function;
+						auto &subquery = replacement_function->Cast<SubqueryRef>();
 						subquery.column_name_alias = ref.column_name_alias;
 					} else {
 						throw InternalException("Replacement scan should return either a table function or a subquery");
@@ -163,7 +163,8 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 
 		D_ASSERT(bound_child->type == TableReferenceType::SUBQUERY);
 		// verify that the types and names match up with the expected types and names
-		auto &bound_subquery = (BoundSubqueryRef &)*bound_child;
+		auto &bound_subquery = bound_child->Cast<BoundSubqueryRef>();
+		;
 		if (bound_subquery.subquery->types != view_catalog_entry->types) {
 			throw BinderException("Contents of view were altered: types don't match!");
 		}