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

package/src/duckdb/src/common/tree_renderer.cpp

@@ -3,12 +3,10 @@
 #include "duckdb/execution/physical_operator.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/pair.hpp"
-#include "duckdb/common/to_string.hpp"
 #include "duckdb/execution/operator/join/physical_delim_join.hpp"
 #include "duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp"
 #include "duckdb/execution/operator/scan/physical_positional_scan.hpp"
 #include "duckdb/parallel/pipeline.hpp"
-
 #include "utf8proc_wrapper.hpp"
 
 #include <sstream>
@@ -394,10 +392,10 @@ void TreeChildrenIterator::Iterate(const PhysicalOperator &op,
 		callback(*child);
 	}
 	if (op.type == PhysicalOperatorType::DELIM_JOIN) {
-		auto &delim = (PhysicalDelimJoin &)op;
+		auto &delim = op.Cast<PhysicalDelimJoin>();
 		callback(*delim.join);
 	} else if ((op.type == PhysicalOperatorType::POSITIONAL_SCAN)) {
-		auto &pscan = (PhysicalPositionalScan &)op;
+		auto &pscan = op.Cast<PhysicalPositionalScan>();
 		for (auto &table : pscan.child_tables) {
 			callback(*table);
 		}

package/src/duckdb/src/common/types.cpp

@@ -847,7 +847,9 @@ bool LogicalType::HasAlias() const {
 
 void LogicalType::SetCatalog(LogicalType &type, TypeCatalogEntry *catalog_entry) {
 	auto info = type.AuxInfo();
-	D_ASSERT(info);
+	if (!info) {
+		return;
+	}
 	((ExtraTypeInfo &)*info).catalog_entry = catalog_entry;
 }
 TypeCatalogEntry *LogicalType::GetCatalog(const LogicalType &type) {

package/src/duckdb/src/execution/column_binding_resolver.cpp

@@ -23,7 +23,7 @@ void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN: {
 		// special case: comparison join
-		auto &comp_join = (LogicalComparisonJoin &)op;
+		auto &comp_join = op.Cast<LogicalComparisonJoin>();
 		// first get the bindings of the LHS and resolve the LHS expressions
 		VisitOperator(*comp_join.children[0]);
 		for (auto &cond : comp_join.conditions) {
@@ -31,7 +31,7 @@ void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
 		}
 		if (op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
 			// visit the duplicate eliminated columns on the LHS, if any
-			auto &delim_join = (LogicalDelimJoin &)op;
+			auto &delim_join = op.Cast<LogicalDelimJoin>();
 			for (auto &expr : delim_join.duplicate_eliminated_columns) {
 				VisitExpression(&expr);
 			}
@@ -51,7 +51,7 @@ void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
 		// this operator
 		VisitOperatorChildren(op);
 		bindings = op.GetColumnBindings();
-		auto &any_join = (LogicalAnyJoin &)op;
+		auto &any_join = op.Cast<LogicalAnyJoin>();
 		if (any_join.join_type == JoinType::SEMI || any_join.join_type == JoinType::ANTI) {
 			auto right_bindings = op.children[1]->GetColumnBindings();
 			bindings.insert(bindings.end(), right_bindings.begin(), right_bindings.end());
@@ -62,7 +62,7 @@ void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
 	case LogicalOperatorType::LOGICAL_CREATE_INDEX: {
 		// CREATE INDEX statement, add the columns of the table with table index 0 to the binding set
 		// afterwards bind the expressions of the CREATE INDEX statement
-		auto &create_index = (LogicalCreateIndex &)op;
+		auto &create_index = op.Cast<LogicalCreateIndex>();
 		bindings = LogicalOperator::GenerateColumnBindings(0, create_index.table.GetColumns().LogicalColumnCount());
 		VisitOperatorExpressions(op);
 		return;
@@ -76,7 +76,7 @@ void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
 	case LogicalOperatorType::LOGICAL_INSERT: {
 		//! We want to execute the normal path, but also add a dummy 'excluded' binding if there is a
 		// ON CONFLICT DO UPDATE clause
-		auto &insert_op = (LogicalInsert &)op;
+		auto &insert_op = op.Cast<LogicalInsert>();
 		if (insert_op.action_type != OnConflictAction::THROW) {
 			// Get the bindings from the children
 			VisitOperatorChildren(op);

package/src/duckdb/src/execution/expression_executor.cpp

@@ -3,6 +3,7 @@
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/execution/execution_context.hpp"
 #include "duckdb/storage/statistics/base_statistics.hpp"
+#include "duckdb/planner/expression/list.hpp"
 
 namespace duckdb {
 
@@ -225,11 +226,11 @@ idx_t ExpressionExecutor::Select(const Expression &expr, ExpressionState *state,
 	D_ASSERT(expr.return_type.id() == LogicalTypeId::BOOLEAN);
 	switch (expr.expression_class) {
 	case ExpressionClass::BOUND_BETWEEN:
-		return Select((BoundBetweenExpression &)expr, state, sel, count, true_sel, false_sel);
+		return Select(expr.Cast<BoundBetweenExpression>(), state, sel, count, true_sel, false_sel);
 	case ExpressionClass::BOUND_COMPARISON:
-		return Select((BoundComparisonExpression &)expr, state, sel, count, true_sel, false_sel);
+		return Select(expr.Cast<BoundComparisonExpression>(), state, sel, count, true_sel, false_sel);
 	case ExpressionClass::BOUND_CONJUNCTION:
-		return Select((BoundConjunctionExpression &)expr, state, sel, count, true_sel, false_sel);
+		return Select(expr.Cast<BoundConjunctionExpression>(), state, sel, count, true_sel, false_sel);
 	default:
 		return DefaultSelect(expr, state, sel, count, true_sel, false_sel);
 	}

package/src/duckdb/src/execution/expression_executor_state.cpp

@@ -26,7 +26,7 @@ bool ExpressionState::HasContext() {
 
 ClientContext &ExpressionState::GetContext() {
 	if (!HasContext()) {
-		throw BinderException("Cannot use %s in this context", ((BoundFunctionExpression &)expr).function.name);
+		throw BinderException("Cannot use %s in this context", (expr.Cast<BoundFunctionExpression>()).function.name);
 	}
 	return root.executor->GetContext();
 }

package/src/duckdb/src/execution/index/art/art.cpp

@@ -1002,19 +1002,17 @@ BlockPointer ART::Serialize(MetaBlockWriter &writer) {
 //===--------------------------------------------------------------------===//
 // Merging
 //===--------------------------------------------------------------------===//
-
-bool ART::MergeIndexes(IndexLock &state, Index *other_index) {
-
-	auto other_art = (ART *)other_index;
+bool ART::MergeIndexes(IndexLock &state, Index &other_index) {
+	auto &other_art = other_index.Cast<ART>();
 
 	if (!this->tree) {
-		IncreaseMemorySize(other_art->memory_size);
-		tree = other_art->tree;
-		other_art->tree = nullptr;
+		IncreaseMemorySize(other_art.memory_size);
+		tree = other_art.tree;
+		other_art.tree = nullptr;
 		return true;
 	}
 
-	return Node::MergeARTs(this, other_art);
+	return Node::MergeARTs(this, &other_art);
 }
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/execution/operator/aggregate/distinct_aggregate_data.cpp

@@ -16,7 +16,7 @@ DistinctAggregateCollectionInfo::DistinctAggregateCollectionInfo(const vector<un
 
 	total_child_count = 0;
 	for (idx_t i = 0; i < aggregate_count; i++) {
-		auto &aggregate = (BoundAggregateExpression &)*aggregates[i];
+		auto &aggregate = aggregates[i]->Cast<BoundAggregateExpression>();
 
 		if (!aggregate.IsDistinct()) {
 			continue;
@@ -35,7 +35,7 @@ DistinctAggregateState::DistinctAggregateState(const DistinctAggregateData &data
 
 	idx_t aggregate_count = data.info.aggregates.size();
 	for (idx_t i = 0; i < aggregate_count; i++) {
-		auto &aggregate = (BoundAggregateExpression &)*data.info.aggregates[i];
+		auto &aggregate = data.info.aggregates[i]->Cast<BoundAggregateExpression>();
 
 		// Initialize the child executor and get the payload types for every aggregate
 		for (auto &child : aggregate.children) {
@@ -80,7 +80,7 @@ DistinctAggregateData::DistinctAggregateData(const DistinctAggregateCollectionIn
 	grouping_sets.resize(info.table_count);
 
 	for (auto &i : info.indices) {
-		auto &aggregate = (BoundAggregateExpression &)*info.aggregates[i];
+		auto &aggregate = info.aggregates[i]->Cast<BoundAggregateExpression>();
 
 		D_ASSERT(info.table_map.count(i));
 		idx_t table_idx = info.table_map.at(i);
@@ -128,8 +128,8 @@ struct FindMatchingAggregate {
 			return false;
 		}
 		for (idx_t i = 0; i < aggr.children.size(); i++) {
-			auto &other_child = (BoundReferenceExpression &)*other.children[i];
-			auto &aggr_child = (BoundReferenceExpression &)*aggr.children[i];
+			auto &other_child = other.children[i]->Cast<BoundReferenceExpression>();
+			auto &aggr_child = aggr.children[i]->Cast<BoundReferenceExpression>();
 			if (other_child.index != aggr_child.index) {
 				return false;
 			}
@@ -145,7 +145,7 @@ idx_t DistinctAggregateCollectionInfo::CreateTableIndexMap() {
 	D_ASSERT(table_map.empty());
 	for (auto &agg_idx : indices) {
 		D_ASSERT(agg_idx < aggregates.size());
-		auto &aggregate = (BoundAggregateExpression &)*aggregates[agg_idx];
+		auto &aggregate = aggregates[agg_idx]->Cast<BoundAggregateExpression>();
 
 		auto matching_inputs =
 		    std::find_if(table_inputs.begin(), table_inputs.end(), FindMatchingAggregate(std::ref(aggregate)));
@@ -179,7 +179,7 @@ static vector<idx_t> GetDistinctIndices(vector<unique_ptr<Expression>> &aggregat
 	vector<idx_t> distinct_indices;
 	for (idx_t i = 0; i < aggregates.size(); i++) {
 		auto &aggregate = aggregates[i];
-		auto &aggr = (BoundAggregateExpression &)*aggregate;
+		auto &aggr = aggregate->Cast<BoundAggregateExpression>();
 		if (aggr.IsDistinct()) {
 			distinct_indices.push_back(i);
 		}

package/src/duckdb/src/execution/operator/aggregate/grouped_aggregate_data.cpp

@@ -22,7 +22,7 @@ void GroupedAggregateData::InitializeGroupby(vector<unique_ptr<Expression>> grou
 	for (auto &expr : expressions) {
 		D_ASSERT(expr->expression_class == ExpressionClass::BOUND_AGGREGATE);
 		D_ASSERT(expr->IsAggregate());
-		auto &aggr = (BoundAggregateExpression &)*expr;
+		auto &aggr = expr->Cast<BoundAggregateExpression>();
 		bindings.push_back(&aggr);
 
 		aggregate_return_types.push_back(aggr.return_type);
@@ -45,7 +45,7 @@ void GroupedAggregateData::InitializeGroupby(vector<unique_ptr<Expression>> grou
 
 void GroupedAggregateData::InitializeDistinct(const unique_ptr<Expression> &aggregate,
                                               const vector<unique_ptr<Expression>> *groups_p) {
-	auto &aggr = (BoundAggregateExpression &)*aggregate;
+	auto &aggr = aggregate->Cast<BoundAggregateExpression>();
 	D_ASSERT(aggr.IsDistinct());
 
 	// Add the (empty in ungrouped case) groups of the aggregates

package/src/duckdb/src/execution/operator/aggregate/physical_hash_aggregate.cpp

@@ -73,13 +73,13 @@ static vector<LogicalType> CreateGroupChunkTypes(vector<unique_ptr<Expression>>
 
 	for (auto &group : groups) {
 		D_ASSERT(group->type == ExpressionType::BOUND_REF);
-		auto &bound_ref = (BoundReferenceExpression &)*group;
+		auto &bound_ref = group->Cast<BoundReferenceExpression>();
 		group_indices.insert(bound_ref.index);
 	}
 	idx_t highest_index = *group_indices.rbegin();
 	vector<LogicalType> types(highest_index + 1, LogicalType::SQLNULL);
 	for (auto &group : groups) {
-		auto &bound_ref = (BoundReferenceExpression &)*group;
+		auto &bound_ref = group->Cast<BoundReferenceExpression>();
 		types[bound_ref.index] = bound_ref.return_type;
 	}
 	return types;
@@ -139,7 +139,7 @@ PhysicalHashAggregate::PhysicalHashAggregate(ClientContext &context, vector<Logi
 	idx_t aggregate_input_idx = 0;
 	for (idx_t i = 0; i < aggregates.size(); i++) {
 		auto &aggregate = aggregates[i];
-		auto &aggr = (BoundAggregateExpression &)*aggregate;
+		auto &aggr = aggregate->Cast<BoundAggregateExpression>();
 		aggregate_input_idx += aggr.children.size();
 		if (aggr.aggr_type == AggregateType::DISTINCT) {
 			distinct_filter.push_back(i);
@@ -152,9 +152,9 @@ PhysicalHashAggregate::PhysicalHashAggregate(ClientContext &context, vector<Logi
 
 	for (idx_t i = 0; i < aggregates.size(); i++) {
 		auto &aggregate = aggregates[i];
-		auto &aggr = (BoundAggregateExpression &)*aggregate;
+		auto &aggr = aggregate->Cast<BoundAggregateExpression>();
 		if (aggr.filter) {
-			auto &bound_ref_expr = (BoundReferenceExpression &)*aggr.filter;
+			auto &bound_ref_expr = aggr.filter->Cast<BoundReferenceExpression>();
 			if (!filter_indexes.count(aggr.filter.get())) {
 				// Replace the bound reference expression's index with the corresponding index of the payload chunk
 				filter_indexes[aggr.filter.get()] = bound_ref_expr.index;
@@ -184,7 +184,7 @@ public:
 		}
 		vector<LogicalType> filter_types;
 		for (auto &aggr : op.grouped_aggregate_data.aggregates) {
-			auto &aggregate = (BoundAggregateExpression &)*aggr;
+			auto &aggregate = aggr->Cast<BoundAggregateExpression>();
 			for (auto &child : aggregate.children) {
 				payload_types.push_back(child->return_type);
 			}
@@ -219,7 +219,7 @@ public:
 		// the filtering of data for the regular aggregates is done within the hashtable
 		vector<AggregateObject> aggregate_objects;
 		for (auto &aggregate : op.grouped_aggregate_data.aggregates) {
-			auto &aggr = (BoundAggregateExpression &)*aggregate;
+			auto &aggr = aggregate->Cast<BoundAggregateExpression>();
 			aggregate_objects.emplace_back(&aggr);
 		}
 
@@ -232,7 +232,7 @@ public:
 };
 
 void PhysicalHashAggregate::SetMultiScan(GlobalSinkState &state) {
-	auto &gstate = (HashAggregateGlobalState &)state;
+	auto &gstate = state.Cast<HashAggregateGlobalState>();
 	for (auto &grouping_state : gstate.grouping_states) {
 		auto &radix_state = grouping_state.table_state;
 		RadixPartitionedHashTable::SetMultiScan(*radix_state);
@@ -252,8 +252,8 @@ unique_ptr<LocalSinkState> PhysicalHashAggregate::GetLocalSinkState(ExecutionCon
 
 void PhysicalHashAggregate::SinkDistinctGrouping(ExecutionContext &context, GlobalSinkState &state,
                                                  LocalSinkState &lstate, DataChunk &input, idx_t grouping_idx) const {
-	auto &sink = (HashAggregateLocalState &)lstate;
-	auto &global_sink = (HashAggregateGlobalState &)state;
+	auto &sink = lstate.Cast<HashAggregateLocalState>();
+	auto &global_sink = state.Cast<HashAggregateGlobalState>();
 
 	auto &grouping_gstate = global_sink.grouping_states[grouping_idx];
 	auto &grouping_lstate = sink.grouping_states[grouping_idx];
@@ -268,7 +268,7 @@ void PhysicalHashAggregate::SinkDistinctGrouping(ExecutionContext &context, Glob
 	vector<idx_t> empty_filter;
 
 	for (idx_t &idx : distinct_info.indices) {
-		auto &aggregate = (BoundAggregateExpression &)*grouped_aggregate_data.aggregates[idx];
+		auto &aggregate = grouped_aggregate_data.aggregates[idx]->Cast<BoundAggregateExpression>();
 
 		D_ASSERT(distinct_info.table_map.count(idx));
 		idx_t table_idx = distinct_info.table_map[idx];
@@ -289,7 +289,7 @@ void PhysicalHashAggregate::SinkDistinctGrouping(ExecutionContext &context, Glob
 			auto it = filter_indexes.find(aggregate.filter.get());
 			D_ASSERT(it != filter_indexes.end());
 			D_ASSERT(it->second < input.data.size());
-			auto &filter_bound_ref = (BoundReferenceExpression &)*aggregate.filter;
+			auto &filter_bound_ref = aggregate.filter->Cast<BoundReferenceExpression>();
 			filter_chunk.data[filter_bound_ref.index].Reference(input.data[it->second]);
 			filter_chunk.SetCardinality(input.size());
 
@@ -309,12 +309,12 @@ void PhysicalHashAggregate::SinkDistinctGrouping(ExecutionContext &context, Glob
 
 			for (idx_t group_idx = 0; group_idx < grouped_aggregate_data.groups.size(); group_idx++) {
 				auto &group = grouped_aggregate_data.groups[group_idx];
-				auto &bound_ref = (BoundReferenceExpression &)*group;
+				auto &bound_ref = group->Cast<BoundReferenceExpression>();
 				filtered_input.data[bound_ref.index].Reference(input.data[bound_ref.index]);
 			}
 			for (idx_t child_idx = 0; child_idx < aggregate.children.size(); child_idx++) {
 				auto &child = aggregate.children[child_idx];
-				auto &bound_ref = (BoundReferenceExpression &)*child;
+				auto &bound_ref = child->Cast<BoundReferenceExpression>();
 
 				filtered_input.data[bound_ref.index].Reference(input.data[bound_ref.index]);
 			}
@@ -337,8 +337,8 @@ void PhysicalHashAggregate::SinkDistinct(ExecutionContext &context, GlobalSinkSt
 
 SinkResultType PhysicalHashAggregate::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
                                            DataChunk &input) const {
-	auto &llstate = (HashAggregateLocalState &)lstate;
-	auto &gstate = (HashAggregateGlobalState &)state;
+	auto &llstate = lstate.Cast<HashAggregateLocalState>();
+	auto &gstate = state.Cast<HashAggregateGlobalState>();
 
 	if (distinct_collection_info) {
 		SinkDistinct(context, state, lstate, input);
@@ -355,17 +355,17 @@ SinkResultType PhysicalHashAggregate::Sink(ExecutionContext &context, GlobalSink
 
 	// Populate the aggregate child vectors
 	for (auto &aggregate : aggregates) {
-		auto &aggr = (BoundAggregateExpression &)*aggregate;
+		auto &aggr = aggregate->Cast<BoundAggregateExpression>();
 		for (auto &child_expr : aggr.children) {
 			D_ASSERT(child_expr->type == ExpressionType::BOUND_REF);
-			auto &bound_ref_expr = (BoundReferenceExpression &)*child_expr;
+			auto &bound_ref_expr = child_expr->Cast<BoundReferenceExpression>();
 			D_ASSERT(bound_ref_expr.index < input.data.size());
 			aggregate_input_chunk.data[aggregate_input_idx++].Reference(input.data[bound_ref_expr.index]);
 		}
 	}
 	// Populate the filter vectors
 	for (auto &aggregate : aggregates) {
-		auto &aggr = (BoundAggregateExpression &)*aggregate;
+		auto &aggr = aggregate->Cast<BoundAggregateExpression>();
 		if (aggr.filter) {
 			auto it = filter_indexes.find(aggr.filter.get());
 			D_ASSERT(it != filter_indexes.end());
@@ -393,8 +393,8 @@ SinkResultType PhysicalHashAggregate::Sink(ExecutionContext &context, GlobalSink
 
 void PhysicalHashAggregate::CombineDistinct(ExecutionContext &context, GlobalSinkState &state,
                                             LocalSinkState &lstate) const {
-	auto &global_sink = (HashAggregateGlobalState &)state;
-	auto &sink = (HashAggregateLocalState &)lstate;
+	auto &global_sink = state.Cast<HashAggregateGlobalState>();
+	auto &sink = lstate.Cast<HashAggregateLocalState>();
 
 	if (!distinct_collection_info) {
 		return;
@@ -421,8 +421,8 @@ void PhysicalHashAggregate::CombineDistinct(ExecutionContext &context, GlobalSin
 }
 
 void PhysicalHashAggregate::Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const {
-	auto &gstate = (HashAggregateGlobalState &)state;
-	auto &llstate = (HashAggregateLocalState &)lstate;
+	auto &gstate = state.Cast<HashAggregateGlobalState>();
+	auto &llstate = lstate.Cast<HashAggregateLocalState>();
 
 	CombineDistinct(context, state, lstate);
 
@@ -553,7 +553,7 @@ public:
 		idx_t next_payload_idx = 0;
 
 		for (idx_t i = 0; i < op.grouped_aggregate_data.aggregates.size(); i++) {
-			auto &aggregate = (BoundAggregateExpression &)*aggregates[i];
+			auto &aggregate = aggregates[i]->Cast<BoundAggregateExpression>();
 
 			// Forward the payload idx
 			payload_idx = next_payload_idx;
@@ -590,7 +590,7 @@ public:
 
 				for (idx_t group_idx = 0; group_idx < group_by_size; group_idx++) {
 					auto &group = grouped_aggregate_data.groups[group_idx];
-					auto &bound_ref_expr = (BoundReferenceExpression &)*group;
+					auto &bound_ref_expr = group->Cast<BoundReferenceExpression>();
 					group_chunk.data[bound_ref_expr.index].Reference(output_chunk.data[group_idx]);
 				}
 				group_chunk.SetCardinality(output_chunk);
@@ -681,7 +681,7 @@ private:
 
 			for (idx_t i = 0; i < op.grouped_aggregate_data.aggregates.size(); i++) {
 				auto &aggregate = op.grouped_aggregate_data.aggregates[i];
-				auto &aggr = (BoundAggregateExpression &)*aggregate;
+				auto &aggr = aggregate->Cast<BoundAggregateExpression>();
 
 				if (!aggr.IsDistinct()) {
 					aggregate_sources.push_back(nullptr);
@@ -743,7 +743,7 @@ public:
 
 SinkFinalizeType PhysicalHashAggregate::FinalizeDistinct(Pipeline &pipeline, Event &event, ClientContext &context,
                                                          GlobalSinkState &gstate_p) const {
-	auto &gstate = (HashAggregateGlobalState &)gstate_p;
+	auto &gstate = gstate_p.Cast<HashAggregateGlobalState>();
 	D_ASSERT(distinct_collection_info);
 
 	bool any_partitioned = false;
@@ -779,7 +779,7 @@ SinkFinalizeType PhysicalHashAggregate::FinalizeDistinct(Pipeline &pipeline, Eve
 
 SinkFinalizeType PhysicalHashAggregate::FinalizeInternal(Pipeline &pipeline, Event &event, ClientContext &context,
                                                          GlobalSinkState &gstate_p, bool check_distinct) const {
-	auto &gstate = (HashAggregateGlobalState &)gstate_p;
+	auto &gstate = gstate_p.Cast<HashAggregateGlobalState>();
 
 	if (check_distinct && distinct_collection_info) {
 		// There are distinct aggregates
@@ -836,7 +836,7 @@ public:
 			return 1;
 		}
 
-		auto &ht_state = (HashAggregateGlobalState &)*op.sink_state;
+		auto &ht_state = op.sink_state->Cast<HashAggregateGlobalState>();
 		idx_t count = 0;
 		for (size_t sidx = 0; sidx < op.groupings.size(); ++sidx) {
 			auto &grouping = op.groupings[sidx];
@@ -870,9 +870,9 @@ unique_ptr<LocalSourceState> PhysicalHashAggregate::GetLocalSourceState(Executio
 
 void PhysicalHashAggregate::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
                                     LocalSourceState &lstate_p) const {
-	auto &sink_gstate = (HashAggregateGlobalState &)*sink_state;
-	auto &gstate = (PhysicalHashAggregateGlobalSourceState &)gstate_p;
-	auto &lstate = (PhysicalHashAggregateLocalSourceState &)lstate_p;
+	auto &sink_gstate = sink_state->Cast<HashAggregateGlobalState>();
+	auto &gstate = gstate_p.Cast<PhysicalHashAggregateGlobalSourceState>();
+	auto &lstate = lstate_p.Cast<PhysicalHashAggregateLocalSourceState>();
 	while (true) {
 		idx_t radix_idx = gstate.state_index;
 		if (radix_idx >= groupings.size()) {
@@ -908,7 +908,7 @@ string PhysicalHashAggregate::ParamsToString() const {
 		result += groups[i]->GetName();
 	}
 	for (idx_t i = 0; i < aggregates.size(); i++) {
-		auto &aggregate = (BoundAggregateExpression &)*aggregates[i];
+		auto &aggregate = aggregates[i]->Cast<BoundAggregateExpression>();
 		if (i > 0 || !groups.empty()) {
 			result += "\n";
 		}

package/src/duckdb/src/execution/operator/aggregate/physical_perfecthash_aggregate.cpp

@@ -31,7 +31,7 @@ PhysicalPerfectHashAggregate::PhysicalPerfectHashAggregate(ClientContext &contex
 	for (auto &expr : aggregates) {
 		D_ASSERT(expr->expression_class == ExpressionClass::BOUND_AGGREGATE);
 		D_ASSERT(expr->IsAggregate());
-		auto &aggr = (BoundAggregateExpression &)*expr;
+		auto &aggr = expr->Cast<BoundAggregateExpression>();
 		bindings.push_back(&aggr);
 
 		D_ASSERT(!aggr.IsDistinct());
@@ -51,13 +51,13 @@ PhysicalPerfectHashAggregate::PhysicalPerfectHashAggregate(ClientContext &contex
 	// filter_indexes must be pre-built, not lazily instantiated in parallel...
 	idx_t aggregate_input_idx = 0;
 	for (auto &aggregate : aggregates) {
-		auto &aggr = (BoundAggregateExpression &)*aggregate;
+		auto &aggr = aggregate->Cast<BoundAggregateExpression>();
 		aggregate_input_idx += aggr.children.size();
 	}
 	for (auto &aggregate : aggregates) {
-		auto &aggr = (BoundAggregateExpression &)*aggregate;
+		auto &aggr = aggregate->Cast<BoundAggregateExpression>();
 		if (aggr.filter) {
-			auto &bound_ref_expr = (BoundReferenceExpression &)*aggr.filter;
+			auto &bound_ref_expr = aggr.filter->Cast<BoundReferenceExpression>();
 			auto it = filter_indexes.find(aggr.filter.get());
 			if (it == filter_indexes.end()) {
 				filter_indexes[aggr.filter.get()] = bound_ref_expr.index;
@@ -116,27 +116,27 @@ unique_ptr<LocalSinkState> PhysicalPerfectHashAggregate::GetLocalSinkState(Execu
 
 SinkResultType PhysicalPerfectHashAggregate::Sink(ExecutionContext &context, GlobalSinkState &state,
                                                   LocalSinkState &lstate_p, DataChunk &input) const {
-	auto &lstate = (PerfectHashAggregateLocalState &)lstate_p;
+	auto &lstate = lstate_p.Cast<PerfectHashAggregateLocalState>();
 	DataChunk &group_chunk = lstate.group_chunk;
 	DataChunk &aggregate_input_chunk = lstate.aggregate_input_chunk;
 
 	for (idx_t group_idx = 0; group_idx < groups.size(); group_idx++) {
 		auto &group = groups[group_idx];
 		D_ASSERT(group->type == ExpressionType::BOUND_REF);
-		auto &bound_ref_expr = (BoundReferenceExpression &)*group;
+		auto &bound_ref_expr = group->Cast<BoundReferenceExpression>();
 		group_chunk.data[group_idx].Reference(input.data[bound_ref_expr.index]);
 	}
 	idx_t aggregate_input_idx = 0;
 	for (auto &aggregate : aggregates) {
-		auto &aggr = (BoundAggregateExpression &)*aggregate;
+		auto &aggr = aggregate->Cast<BoundAggregateExpression>();
 		for (auto &child_expr : aggr.children) {
 			D_ASSERT(child_expr->type == ExpressionType::BOUND_REF);
-			auto &bound_ref_expr = (BoundReferenceExpression &)*child_expr;
+			auto &bound_ref_expr = child_expr->Cast<BoundReferenceExpression>();
 			aggregate_input_chunk.data[aggregate_input_idx++].Reference(input.data[bound_ref_expr.index]);
 		}
 	}
 	for (auto &aggregate : aggregates) {
-		auto &aggr = (BoundAggregateExpression &)*aggregate;
+		auto &aggr = aggregate->Cast<BoundAggregateExpression>();
 		if (aggr.filter) {
 			auto it = filter_indexes.find(aggr.filter.get());
 			D_ASSERT(it != filter_indexes.end());
@@ -161,8 +161,8 @@ SinkResultType PhysicalPerfectHashAggregate::Sink(ExecutionContext &context, Glo
 //===--------------------------------------------------------------------===//
 void PhysicalPerfectHashAggregate::Combine(ExecutionContext &context, GlobalSinkState &gstate_p,
                                            LocalSinkState &lstate_p) const {
-	auto &lstate = (PerfectHashAggregateLocalState &)lstate_p;
-	auto &gstate = (PerfectHashAggregateGlobalState &)gstate_p;
+	auto &lstate = lstate_p.Cast<PerfectHashAggregateLocalState>();
+	auto &gstate = gstate_p.Cast<PerfectHashAggregateGlobalState>();
 
 	lock_guard<mutex> l(gstate.lock);
 	gstate.ht->Combine(*lstate.ht);
@@ -187,7 +187,7 @@ unique_ptr<GlobalSourceState> PhysicalPerfectHashAggregate::GetGlobalSourceState
 void PhysicalPerfectHashAggregate::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
                                            LocalSourceState &lstate) const {
 	auto &state = (PerfectHashAggregateState &)gstate_p;
-	auto &gstate = (PerfectHashAggregateGlobalState &)*sink_state;
+	auto &gstate = sink_state->Cast<PerfectHashAggregateGlobalState>();
 
 	gstate.ht->Scan(state.ht_scan_position, chunk);
 }
@@ -205,7 +205,7 @@ string PhysicalPerfectHashAggregate::ParamsToString() const {
 			result += "\n";
 		}
 		result += aggregates[i]->GetName();
-		auto &aggregate = (BoundAggregateExpression &)*aggregates[i];
+		auto &aggregate = aggregates[i]->Cast<BoundAggregateExpression>();
 		if (aggregate.filter) {
 			result += " Filter: " + aggregate.filter->GetName();
 		}

package/src/duckdb/src/execution/operator/aggregate/physical_streaming_window.cpp

@@ -46,7 +46,7 @@ public:
 
 		for (idx_t expr_idx = 0; expr_idx < expressions.size(); expr_idx++) {
 			auto &expr = *expressions[expr_idx];
-			auto &wexpr = (BoundWindowExpression &)expr;
+			auto &wexpr = expr.Cast<BoundWindowExpression>();
 			switch (expr.GetExpressionType()) {
 			case ExpressionType::WINDOW_AGGREGATE: {
 				auto &aggregate = *wexpr.aggregate;
@@ -104,7 +104,7 @@ unique_ptr<OperatorState> PhysicalStreamingWindow::GetOperatorState(ExecutionCon
 
 OperatorResultType PhysicalStreamingWindow::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
                                                     GlobalOperatorState &gstate_p, OperatorState &state_p) const {
-	auto &gstate = (StreamingWindowGlobalState &)gstate_p;
+	auto &gstate = gstate_p.Cast<StreamingWindowGlobalState>();
 	auto &state = (StreamingWindowState &)state_p;
 	if (!state.initialized) {
 		state.Initialize(context.client, input, select_list);
@@ -122,7 +122,7 @@ OperatorResultType PhysicalStreamingWindow::Execute(ExecutionContext &context, D
 		switch (expr.GetExpressionType()) {
 		case ExpressionType::WINDOW_AGGREGATE: {
 			//	Establish the aggregation environment
-			auto &wexpr = (BoundWindowExpression &)expr;
+			auto &wexpr = expr.Cast<BoundWindowExpression>();
 			auto &aggregate = *wexpr.aggregate;
 			auto &statev = state.statev;
 			state.state_ptr = state.aggregate_states[expr_idx].data();