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

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

@@ -37,7 +37,7 @@ struct AggregateState {
 	explicit AggregateState(const vector<unique_ptr<Expression>> &aggregate_expressions) {
 		for (auto &aggregate : aggregate_expressions) {
 			D_ASSERT(aggregate->GetExpressionClass() == ExpressionClass::BOUND_AGGREGATE);
-			auto &aggr = (BoundAggregateExpression &)*aggregate;
+			auto &aggr = aggregate->Cast<BoundAggregateExpression>();
 			auto state = unique_ptr<data_t[]>(new data_t[aggr.function.state_size()]);
 			aggr.function.initialize(state.get());
 			aggregates.push_back(std::move(state));
@@ -97,7 +97,7 @@ public:
 	UngroupedAggregateLocalState(const PhysicalUngroupedAggregate &op, const vector<LogicalType> &child_types,
 	                             GlobalSinkState &gstate_p, ExecutionContext &context)
 	    : state(op.aggregates), child_executor(context.client), aggregate_input_chunk(), filter_set() {
-		auto &gstate = (UngroupedAggregateGlobalState &)gstate_p;
+		auto &gstate = gstate_p.Cast<UngroupedAggregateGlobalState>();
 
 		auto &allocator = Allocator::Get(context.client);
 		InitializeDistinctAggregates(op, gstate, context);
@@ -106,7 +106,7 @@ public:
 		vector<AggregateObject> aggregate_objects;
 		for (auto &aggregate : op.aggregates) {
 			D_ASSERT(aggregate->GetExpressionClass() == ExpressionClass::BOUND_AGGREGATE);
-			auto &aggr = (BoundAggregateExpression &)*aggregate;
+			auto &aggr = aggregate->Cast<BoundAggregateExpression>();
 			// initialize the payload chunk
 			for (auto &child : aggr.children) {
 				payload_types.push_back(child->return_type);
@@ -174,8 +174,8 @@ unique_ptr<LocalSinkState> PhysicalUngroupedAggregate::GetLocalSinkState(Executi
 
 void PhysicalUngroupedAggregate::SinkDistinct(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
                                               DataChunk &input) const {
-	auto &sink = (UngroupedAggregateLocalState &)lstate;
-	auto &global_sink = (UngroupedAggregateGlobalState &)state;
+	auto &sink = lstate.Cast<UngroupedAggregateLocalState>();
+	auto &global_sink = state.Cast<UngroupedAggregateGlobalState>();
 	D_ASSERT(distinct_data);
 	auto &distinct_state = *global_sink.distinct_state;
 	auto &distinct_info = *distinct_collection_info;
@@ -186,7 +186,7 @@ void PhysicalUngroupedAggregate::SinkDistinct(ExecutionContext &context, GlobalS
 	auto &distinct_filter = distinct_info.Indices();
 
 	for (auto &idx : distinct_indices) {
-		auto &aggregate = (BoundAggregateExpression &)*aggregates[idx];
+		auto &aggregate = aggregates[idx]->Cast<BoundAggregateExpression>();
 
 		idx_t table_idx = distinct_info.table_map[idx];
 		if (!distinct_data->radix_tables[table_idx]) {
@@ -217,7 +217,7 @@ void PhysicalUngroupedAggregate::SinkDistinct(ExecutionContext &context, GlobalS
 
 SinkResultType PhysicalUngroupedAggregate::Sink(ExecutionContext &context, GlobalSinkState &state,
                                                 LocalSinkState &lstate, DataChunk &input) const {
-	auto &sink = (UngroupedAggregateLocalState &)lstate;
+	auto &sink = lstate.Cast<UngroupedAggregateLocalState>();
 
 	// perform the aggregation inside the local state
 	sink.Reset();
@@ -232,7 +232,7 @@ SinkResultType PhysicalUngroupedAggregate::Sink(ExecutionContext &context, Globa
 	idx_t next_payload_idx = 0;
 
 	for (idx_t aggr_idx = 0; aggr_idx < aggregates.size(); aggr_idx++) {
-		auto &aggregate = (BoundAggregateExpression &)*aggregates[aggr_idx];
+		auto &aggregate = aggregates[aggr_idx]->Cast<BoundAggregateExpression>();
 
 		payload_idx = next_payload_idx;
 		next_payload_idx = payload_idx + aggregate.children.size();
@@ -279,8 +279,8 @@ SinkResultType PhysicalUngroupedAggregate::Sink(ExecutionContext &context, Globa
 
 void PhysicalUngroupedAggregate::CombineDistinct(ExecutionContext &context, GlobalSinkState &state,
                                                  LocalSinkState &lstate) const {
-	auto &global_sink = (UngroupedAggregateGlobalState &)state;
-	auto &source = (UngroupedAggregateLocalState &)lstate;
+	auto &global_sink = state.Cast<UngroupedAggregateGlobalState>();
+	auto &source = lstate.Cast<UngroupedAggregateLocalState>();
 
 	if (!distinct_data) {
 		return;
@@ -299,8 +299,8 @@ void PhysicalUngroupedAggregate::CombineDistinct(ExecutionContext &context, Glob
 
 void PhysicalUngroupedAggregate::Combine(ExecutionContext &context, GlobalSinkState &state,
                                          LocalSinkState &lstate) const {
-	auto &gstate = (UngroupedAggregateGlobalState &)state;
-	auto &source = (UngroupedAggregateLocalState &)lstate;
+	auto &gstate = state.Cast<UngroupedAggregateGlobalState>();
+	auto &source = lstate.Cast<UngroupedAggregateLocalState>();
 	D_ASSERT(!gstate.finished);
 
 	// finalize: combine the local state into the global state
@@ -311,7 +311,7 @@ void PhysicalUngroupedAggregate::Combine(ExecutionContext &context, GlobalSinkSt
 	CombineDistinct(context, state, lstate);
 
 	for (idx_t aggr_idx = 0; aggr_idx < aggregates.size(); aggr_idx++) {
-		auto &aggregate = (BoundAggregateExpression &)*aggregates[aggr_idx];
+		auto &aggregate = aggregates[aggr_idx]->Cast<BoundAggregateExpression>();
 
 		if (aggregate.IsDistinct()) {
 			continue;
@@ -353,7 +353,7 @@ public:
 		idx_t next_payload_idx = 0;
 
 		for (idx_t i = 0; i < aggregates.size(); i++) {
-			auto &aggregate = (BoundAggregateExpression &)*aggregates[i];
+			auto &aggregate = aggregates[i]->Cast<BoundAggregateExpression>();
 
 			// Forward the payload idx
 			payload_idx = next_payload_idx;
@@ -478,7 +478,7 @@ public:
 
 SinkFinalizeType PhysicalUngroupedAggregate::FinalizeDistinct(Pipeline &pipeline, Event &event, ClientContext &context,
                                                               GlobalSinkState &gstate_p) const {
-	auto &gstate = (UngroupedAggregateGlobalState &)gstate_p;
+	auto &gstate = gstate_p.Cast<UngroupedAggregateGlobalState>();
 	D_ASSERT(distinct_data);
 	auto &distinct_state = *gstate.distinct_state;
 
@@ -505,7 +505,7 @@ SinkFinalizeType PhysicalUngroupedAggregate::FinalizeDistinct(Pipeline &pipeline
 
 SinkFinalizeType PhysicalUngroupedAggregate::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
                                                       GlobalSinkState &gstate_p) const {
-	auto &gstate = (UngroupedAggregateGlobalState &)gstate_p;
+	auto &gstate = gstate_p.Cast<UngroupedAggregateGlobalState>();
 
 	if (distinct_data) {
 		return FinalizeDistinct(pipeline, event, context, gstate_p);
@@ -534,7 +534,7 @@ unique_ptr<GlobalSourceState> PhysicalUngroupedAggregate::GetGlobalSourceState(C
 void VerifyNullHandling(DataChunk &chunk, AggregateState &state, const vector<unique_ptr<Expression>> &aggregates) {
 #ifdef DEBUG
 	for (idx_t aggr_idx = 0; aggr_idx < aggregates.size(); aggr_idx++) {
-		auto &aggr = (BoundAggregateExpression &)*aggregates[aggr_idx];
+		auto &aggr = aggregates[aggr_idx]->Cast<BoundAggregateExpression>();
 		if (state.counts[aggr_idx] == 0 && aggr.function.null_handling == FunctionNullHandling::DEFAULT_NULL_HANDLING) {
 			// Default is when 0 values go in, NULL comes out
 			UnifiedVectorFormat vdata;
@@ -547,7 +547,7 @@ void VerifyNullHandling(DataChunk &chunk, AggregateState &state, const vector<un
 
 void PhysicalUngroupedAggregate::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
                                          LocalSourceState &lstate) const {
-	auto &gstate = (UngroupedAggregateGlobalState &)*sink_state;
+	auto &gstate = sink_state->Cast<UngroupedAggregateGlobalState>();
 	auto &state = (UngroupedAggregateState &)gstate_p;
 	D_ASSERT(gstate.finished);
 	if (state.finished) {
@@ -557,7 +557,7 @@ void PhysicalUngroupedAggregate::GetData(ExecutionContext &context, DataChunk &c
 	// initialize the result chunk with the aggregate values
 	chunk.SetCardinality(1);
 	for (idx_t aggr_idx = 0; aggr_idx < aggregates.size(); aggr_idx++) {
-		auto &aggregate = (BoundAggregateExpression &)*aggregates[aggr_idx];
+		auto &aggregate = aggregates[aggr_idx]->Cast<BoundAggregateExpression>();
 
 		Vector state_vector(Value::POINTER((uintptr_t)gstate.state.aggregates[aggr_idx].get()));
 		AggregateInputData aggr_input_data(aggregate.bind_info.get(), Allocator::DefaultAllocator());
@@ -570,7 +570,7 @@ void PhysicalUngroupedAggregate::GetData(ExecutionContext &context, DataChunk &c
 string PhysicalUngroupedAggregate::ParamsToString() const {
 	string result;
 	for (idx_t i = 0; i < aggregates.size(); i++) {
-		auto &aggregate = (BoundAggregateExpression &)*aggregates[i];
+		auto &aggregate = aggregates[i]->Cast<BoundAggregateExpression>();
 		if (i > 0) {
 			result += "\n";
 		}

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

@@ -454,7 +454,7 @@ PhysicalWindow::PhysicalWindow(vector<LogicalType> types, vector<unique_ptr<Expr
 	is_order_dependent = false;
 	for (auto &expr : select_list) {
 		D_ASSERT(expr->expression_class == ExpressionClass::BOUND_WINDOW);
-		auto &bound_window = (BoundWindowExpression &)*expr;
+		auto &bound_window = expr->Cast<BoundWindowExpression>();
 		if (bound_window.partitions.empty() && bound_window.orders.empty()) {
 			is_order_dependent = true;
 		}
@@ -1423,8 +1423,8 @@ void WindowExecutor::Evaluate(idx_t row_idx, DataChunk &input_chunk, Vector &res
 //===--------------------------------------------------------------------===//
 SinkResultType PhysicalWindow::Sink(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p,
                                     DataChunk &input) const {
-	auto &gstate = (WindowGlobalSinkState &)gstate_p;
-	auto &lstate = (WindowLocalSinkState &)lstate_p;
+	auto &gstate = gstate_p.Cast<WindowGlobalSinkState>();
+	auto &lstate = lstate_p.Cast<WindowLocalSinkState>();
 
 	lstate.Sink(input, gstate);
 
@@ -1432,8 +1432,8 @@ SinkResultType PhysicalWindow::Sink(ExecutionContext &context, GlobalSinkState &
 }
 
 void PhysicalWindow::Combine(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const {
-	auto &gstate = (WindowGlobalSinkState &)gstate_p;
-	auto &lstate = (WindowLocalSinkState &)lstate_p;
+	auto &gstate = gstate_p.Cast<WindowGlobalSinkState>();
+	auto &lstate = lstate_p.Cast<WindowLocalSinkState>();
 	lstate.Combine(gstate);
 }
 
@@ -1720,7 +1720,7 @@ public:
 
 SinkFinalizeType PhysicalWindow::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
                                           GlobalSinkState &gstate_p) const {
-	auto &state = (WindowGlobalSinkState &)gstate_p;
+	auto &state = gstate_p.Cast<WindowGlobalSinkState>();
 
 	//	Did we get any data?
 	if (!state.count) {
@@ -1761,7 +1761,7 @@ public:
 
 public:
 	idx_t MaxThreads() override {
-		auto &state = (WindowGlobalSinkState &)*op.sink_state;
+		auto &state = op.sink_state->Cast<WindowGlobalSinkState>();
 
 		// If there is only one partition, we have to process it on one thread.
 		if (!state.grouping_data) {
@@ -1870,7 +1870,7 @@ void WindowLocalSourceState::MaterializeSortedData() {
 }
 
 void WindowLocalSourceState::GeneratePartition(WindowGlobalSinkState &gstate, const idx_t hash_bin_p) {
-	auto &op = (PhysicalWindow &)gstate.op;
+	auto &op = gstate.op.Cast<PhysicalWindow>();
 
 	//	Get rid of any stale data
 	hash_bin = hash_bin_p;
@@ -1990,7 +1990,7 @@ void WindowLocalSourceState::Scan(DataChunk &result) {
 
 unique_ptr<LocalSourceState> PhysicalWindow::GetLocalSourceState(ExecutionContext &context,
                                                                  GlobalSourceState &gstate_p) const {
-	auto &gstate = (WindowGlobalSourceState &)gstate_p;
+	auto &gstate = gstate_p.Cast<WindowGlobalSourceState>();
 	return make_uniq<WindowLocalSourceState>(*this, context, gstate);
 }
 
@@ -2000,9 +2000,9 @@ unique_ptr<GlobalSourceState> PhysicalWindow::GetGlobalSourceState(ClientContext
 
 void PhysicalWindow::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
                              LocalSourceState &lstate_p) const {
-	auto &state = (WindowLocalSourceState &)lstate_p;
-	auto &global_source = (WindowGlobalSourceState &)gstate_p;
-	auto &gstate = (WindowGlobalSinkState &)*sink_state;
+	auto &state = lstate_p.Cast<WindowLocalSourceState>();
+	auto &global_source = gstate_p.Cast<WindowGlobalSourceState>();
+	auto &gstate = sink_state->Cast<WindowGlobalSinkState>();
 
 	const auto bin_count = gstate.hash_groups.empty() ? 1 : gstate.hash_groups.size();
 

package/src/duckdb/src/execution/operator/helper/physical_batch_collector.cpp

@@ -31,15 +31,15 @@ public:
 
 SinkResultType PhysicalBatchCollector::Sink(ExecutionContext &context, GlobalSinkState &gstate,
                                             LocalSinkState &lstate_p, DataChunk &input) const {
-	auto &state = (BatchCollectorLocalState &)lstate_p;
+	auto &state = lstate_p.Cast<BatchCollectorLocalState>();
 	state.data.Append(input, state.batch_index);
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
 void PhysicalBatchCollector::Combine(ExecutionContext &context, GlobalSinkState &gstate_p,
                                      LocalSinkState &lstate_p) const {
-	auto &gstate = (BatchCollectorGlobalState &)gstate_p;
-	auto &state = (BatchCollectorLocalState &)lstate_p;
+	auto &gstate = gstate_p.Cast<BatchCollectorGlobalState>();
+	auto &state = lstate_p.Cast<BatchCollectorLocalState>();
 
 	lock_guard<mutex> lock(gstate.glock);
 	gstate.data.Merge(state.data);
@@ -47,7 +47,7 @@ void PhysicalBatchCollector::Combine(ExecutionContext &context, GlobalSinkState
 
 SinkFinalizeType PhysicalBatchCollector::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
                                                   GlobalSinkState &gstate_p) const {
-	auto &gstate = (BatchCollectorGlobalState &)gstate_p;
+	auto &gstate = gstate_p.Cast<BatchCollectorGlobalState>();
 	auto collection = gstate.data.FetchCollection();
 	D_ASSERT(collection);
 	auto result = make_uniq<MaterializedQueryResult>(statement_type, properties, names, std::move(collection),
@@ -65,7 +65,7 @@ unique_ptr<GlobalSinkState> PhysicalBatchCollector::GetGlobalSinkState(ClientCon
 }
 
 unique_ptr<QueryResult> PhysicalBatchCollector::GetResult(GlobalSinkState &state) {
-	auto &gstate = (BatchCollectorGlobalState &)state;
+	auto &gstate = state.Cast<BatchCollectorGlobalState>();
 	D_ASSERT(gstate.result);
 	return std::move(gstate.result);
 }

package/src/duckdb/src/execution/operator/helper/physical_explain_analyze.cpp

@@ -19,7 +19,7 @@ SinkResultType PhysicalExplainAnalyze::Sink(ExecutionContext &context, GlobalSin
 
 SinkFinalizeType PhysicalExplainAnalyze::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
                                                   GlobalSinkState &gstate_p) const {
-	auto &gstate = (ExplainAnalyzeStateGlobalState &)gstate_p;
+	auto &gstate = gstate_p.Cast<ExplainAnalyzeStateGlobalState>();
 	auto &profiler = QueryProfiler::Get(context);
 	gstate.analyzed_plan = profiler.ToString();
 	return SinkFinalizeType::READY;
@@ -47,7 +47,7 @@ unique_ptr<GlobalSourceState> PhysicalExplainAnalyze::GetGlobalSourceState(Clien
 void PhysicalExplainAnalyze::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &source_state,
                                      LocalSourceState &lstate) const {
 	auto &state = (ExplainAnalyzeState &)source_state;
-	auto &gstate = (ExplainAnalyzeStateGlobalState &)*sink_state;
+	auto &gstate = sink_state->Cast<ExplainAnalyzeStateGlobalState>();
 	if (state.finished) {
 		return;
 	}

package/src/duckdb/src/execution/operator/helper/physical_limit.cpp

@@ -96,7 +96,7 @@ SinkResultType PhysicalLimit::Sink(ExecutionContext &context, GlobalSinkState &g
                                    DataChunk &input) const {
 
 	D_ASSERT(input.size() > 0);
-	auto &state = (LimitLocalState &)lstate;
+	auto &state = lstate.Cast<LimitLocalState>();
 	auto &limit = state.limit;
 	auto &offset = state.offset;
 
@@ -118,8 +118,8 @@ SinkResultType PhysicalLimit::Sink(ExecutionContext &context, GlobalSinkState &g
 }
 
 void PhysicalLimit::Combine(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const {
-	auto &gstate = (LimitGlobalState &)gstate_p;
-	auto &state = (LimitLocalState &)lstate_p;
+	auto &gstate = gstate_p.Cast<LimitGlobalState>();
+	auto &state = lstate_p.Cast<LimitLocalState>();
 
 	lock_guard<mutex> lock(gstate.glock);
 	gstate.limit = state.limit;
@@ -148,8 +148,8 @@ unique_ptr<GlobalSourceState> PhysicalLimit::GetGlobalSourceState(ClientContext
 
 void PhysicalLimit::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
                             LocalSourceState &lstate) const {
-	auto &gstate = (LimitGlobalState &)*sink_state;
-	auto &state = (LimitSourceState &)gstate_p;
+	auto &gstate = sink_state->Cast<LimitGlobalState>();
+	auto &state = gstate_p.Cast<LimitSourceState>();
 	while (state.current_offset < gstate.limit + gstate.offset) {
 		if (!state.initialized) {
 			gstate.data.InitializeScan(state.scan_state);

package/src/duckdb/src/execution/operator/helper/physical_limit_percent.cpp

@@ -46,7 +46,7 @@ unique_ptr<GlobalSinkState> PhysicalLimitPercent::GetGlobalSinkState(ClientConte
 SinkResultType PhysicalLimitPercent::Sink(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate,
                                           DataChunk &input) const {
 	D_ASSERT(input.size() > 0);
-	auto &state = (LimitPercentGlobalState &)gstate;
+	auto &state = gstate.Cast<LimitPercentGlobalState>();
 	auto &limit_percent = state.limit_percent;
 	auto &offset = state.offset;
 
@@ -88,7 +88,7 @@ public:
 	explicit LimitPercentOperatorState(const PhysicalLimitPercent &op)
 	    : limit(DConstants::INVALID_INDEX), current_offset(0) {
 		D_ASSERT(op.sink_state);
-		auto &gstate = (LimitPercentGlobalState &)*op.sink_state;
+		auto &gstate = op.sink_state->Cast<LimitPercentGlobalState>();
 		gstate.data.InitializeScan(scan_state);
 	}
 
@@ -103,8 +103,8 @@ unique_ptr<GlobalSourceState> PhysicalLimitPercent::GetGlobalSourceState(ClientC
 
 void PhysicalLimitPercent::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
                                    LocalSourceState &lstate) const {
-	auto &gstate = (LimitPercentGlobalState &)*sink_state;
-	auto &state = (LimitPercentOperatorState &)gstate_p;
+	auto &gstate = sink_state->Cast<LimitPercentGlobalState>();
+	auto &state = gstate_p.Cast<LimitPercentOperatorState>();
 	auto &percent_limit = gstate.limit_percent;
 	auto &offset = gstate.offset;
 	auto &limit = state.limit;

package/src/duckdb/src/execution/operator/helper/physical_materialized_collector.cpp

@@ -27,15 +27,15 @@ public:
 
 SinkResultType PhysicalMaterializedCollector::Sink(ExecutionContext &context, GlobalSinkState &gstate_p,
                                                    LocalSinkState &lstate_p, DataChunk &input) const {
-	auto &lstate = (MaterializedCollectorLocalState &)lstate_p;
+	auto &lstate = lstate_p.Cast<MaterializedCollectorLocalState>();
 	lstate.collection->Append(lstate.append_state, input);
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
 void PhysicalMaterializedCollector::Combine(ExecutionContext &context, GlobalSinkState &gstate_p,
                                             LocalSinkState &lstate_p) const {
-	auto &gstate = (MaterializedCollectorGlobalState &)gstate_p;
-	auto &lstate = (MaterializedCollectorLocalState &)lstate_p;
+	auto &gstate = gstate_p.Cast<MaterializedCollectorGlobalState>();
+	auto &lstate = lstate_p.Cast<MaterializedCollectorLocalState>();
 	if (lstate.collection->Count() == 0) {
 		return;
 	}
@@ -62,7 +62,7 @@ unique_ptr<LocalSinkState> PhysicalMaterializedCollector::GetLocalSinkState(Exec
 }
 
 unique_ptr<QueryResult> PhysicalMaterializedCollector::GetResult(GlobalSinkState &state) {
-	auto &gstate = (MaterializedCollectorGlobalState &)state;
+	auto &gstate = state.Cast<MaterializedCollectorGlobalState>();
 	if (!gstate.collection) {
 		gstate.collection = make_uniq<ColumnDataCollection>(Allocator::DefaultAllocator(), types);
 	}

package/src/duckdb/src/execution/operator/helper/physical_reservoir_sample.cpp

@@ -36,7 +36,7 @@ unique_ptr<GlobalSinkState> PhysicalReservoirSample::GetGlobalSinkState(ClientCo
 
 SinkResultType PhysicalReservoirSample::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
                                              DataChunk &input) const {
-	auto &gstate = (SampleGlobalSinkState &)state;
+	auto &gstate = state.Cast<SampleGlobalSinkState>();
 	if (!gstate.sample) {
 		return SinkResultType::FINISHED;
 	}
@@ -53,7 +53,7 @@ SinkResultType PhysicalReservoirSample::Sink(ExecutionContext &context, GlobalSi
 //===--------------------------------------------------------------------===//
 void PhysicalReservoirSample::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
                                       LocalSourceState &lstate) const {
-	auto &sink = (SampleGlobalSinkState &)*this->sink_state;
+	auto &sink = this->sink_state->Cast<SampleGlobalSinkState>();
 	if (!sink.sample) {
 		return;
 	}

package/src/duckdb/src/execution/operator/helper/physical_streaming_limit.cpp

@@ -44,8 +44,8 @@ unique_ptr<GlobalOperatorState> PhysicalStreamingLimit::GetGlobalOperatorState(C
 
 OperatorResultType PhysicalStreamingLimit::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
                                                    GlobalOperatorState &gstate_p, OperatorState &state_p) const {
-	auto &gstate = (StreamingLimitGlobalState &)gstate_p;
-	auto &state = (StreamingLimitOperatorState &)state_p;
+	auto &gstate = gstate_p.Cast<StreamingLimitGlobalState>();
+	auto &state = state_p.Cast<StreamingLimitOperatorState>();
 	auto &limit = state.limit;
 	auto &offset = state.offset;
 	idx_t current_offset = gstate.current_offset.fetch_add(input.size());

package/src/duckdb/src/execution/operator/helper/physical_streaming_sample.cpp

@@ -23,7 +23,7 @@ public:
 
 void PhysicalStreamingSample::SystemSample(DataChunk &input, DataChunk &result, OperatorState &state_p) const {
 	// system sampling: we throw one dice per chunk
-	auto &state = (StreamingSampleOperatorState &)state_p;
+	auto &state = state_p.Cast<StreamingSampleOperatorState>();
 	double rand = state.random.NextRandom();
 	if (rand <= percentage) {
 		// rand is smaller than sample_size: output chunk
@@ -34,7 +34,7 @@ void PhysicalStreamingSample::SystemSample(DataChunk &input, DataChunk &result,
 void PhysicalStreamingSample::BernoulliSample(DataChunk &input, DataChunk &result, OperatorState &state_p) const {
 	// bernoulli sampling: we throw one dice per tuple
 	// then slice the result chunk
-	auto &state = (StreamingSampleOperatorState &)state_p;
+	auto &state = state_p.Cast<StreamingSampleOperatorState>();
 	idx_t result_count = 0;
 	SelectionVector sel(STANDARD_VECTOR_SIZE);
 	for (idx_t i = 0; i < input.size(); i++) {

package/src/duckdb/src/execution/operator/helper/physical_vacuum.cpp

@@ -45,7 +45,7 @@ unique_ptr<GlobalSinkState> PhysicalVacuum::GetGlobalSinkState(ClientContext &co
 
 SinkResultType PhysicalVacuum::Sink(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p,
                                     DataChunk &input) const {
-	auto &lstate = (VacuumLocalSinkState &)lstate_p;
+	auto &lstate = lstate_p.Cast<VacuumLocalSinkState>();
 	D_ASSERT(lstate.column_distinct_stats.size() == info->column_id_map.size());
 
 	for (idx_t col_idx = 0; col_idx < input.data.size(); col_idx++) {
@@ -59,8 +59,8 @@ SinkResultType PhysicalVacuum::Sink(ExecutionContext &context, GlobalSinkState &
 }
 
 void PhysicalVacuum::Combine(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const {
-	auto &gstate = (VacuumGlobalSinkState &)gstate_p;
-	auto &lstate = (VacuumLocalSinkState &)lstate_p;
+	auto &gstate = gstate_p.Cast<VacuumGlobalSinkState>();
+	auto &lstate = lstate_p.Cast<VacuumLocalSinkState>();
 
 	lock_guard<mutex> lock(gstate.stats_lock);
 	D_ASSERT(gstate.column_distinct_stats.size() == lstate.column_distinct_stats.size());
@@ -71,7 +71,7 @@ void PhysicalVacuum::Combine(ExecutionContext &context, GlobalSinkState &gstate_
 
 SinkFinalizeType PhysicalVacuum::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
                                           GlobalSinkState &gstate) const {
-	auto &sink = (VacuumGlobalSinkState &)gstate;
+	auto &sink = gstate.Cast<VacuumGlobalSinkState>();
 
 	auto table = info->table;
 	for (idx_t col_idx = 0; col_idx < sink.column_distinct_stats.size(); col_idx++) {

package/src/duckdb/src/execution/operator/join/physical_blockwise_nl_join.cpp

@@ -51,7 +51,7 @@ unique_ptr<LocalSinkState> PhysicalBlockwiseNLJoin::GetLocalSinkState(ExecutionC
 
 SinkResultType PhysicalBlockwiseNLJoin::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
                                              DataChunk &input) const {
-	auto &gstate = (BlockwiseNLJoinGlobalState &)state;
+	auto &gstate = state.Cast<BlockwiseNLJoinGlobalState>();
 	lock_guard<mutex> nl_lock(gstate.lock);
 	gstate.right_chunks.Append(input);
 	return SinkResultType::NEED_MORE_INPUT;
@@ -62,7 +62,7 @@ SinkResultType PhysicalBlockwiseNLJoin::Sink(ExecutionContext &context, GlobalSi
 //===--------------------------------------------------------------------===//
 SinkFinalizeType PhysicalBlockwiseNLJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
                                                    GlobalSinkState &gstate_p) const {
-	auto &gstate = (BlockwiseNLJoinGlobalState &)gstate_p;
+	auto &gstate = gstate_p.Cast<BlockwiseNLJoinGlobalState>();
 	gstate.right_outer.Initialize(gstate.right_chunks.Count());
 
 	if (gstate.right_chunks.Count() == 0 && EmptyResultIfRHSIsEmpty()) {
@@ -91,7 +91,7 @@ public:
 };
 
 unique_ptr<OperatorState> PhysicalBlockwiseNLJoin::GetOperatorState(ExecutionContext &context) const {
-	auto &gstate = (BlockwiseNLJoinGlobalState &)*sink_state;
+	auto &gstate = sink_state->Cast<BlockwiseNLJoinGlobalState>();
 	auto result = make_uniq<BlockwiseNLJoinState>(context, gstate.right_chunks, *this);
 	if (join_type == JoinType::SEMI || join_type == JoinType::ANTI) {
 		vector<LogicalType> intermediate_types;
@@ -111,7 +111,7 @@ OperatorResultType PhysicalBlockwiseNLJoin::ExecuteInternal(ExecutionContext &co
                                                             OperatorState &state_p) const {
 	D_ASSERT(input.size() > 0);
 	auto &state = (BlockwiseNLJoinState &)state_p;
-	auto &gstate = (BlockwiseNLJoinGlobalState &)*sink_state;
+	auto &gstate = sink_state->Cast<BlockwiseNLJoinGlobalState>();
 
 	if (gstate.right_chunks.Count() == 0) {
 		// empty RHS
@@ -212,7 +212,7 @@ class BlockwiseNLJoinGlobalScanState : public GlobalSourceState {
 public:
 	explicit BlockwiseNLJoinGlobalScanState(const PhysicalBlockwiseNLJoin &op) : op(op) {
 		D_ASSERT(op.sink_state);
-		auto &sink = (BlockwiseNLJoinGlobalState &)*op.sink_state;
+		auto &sink = op.sink_state->Cast<BlockwiseNLJoinGlobalState>();
 		sink.right_outer.InitializeScan(sink.right_chunks, scan_state);
 	}
 
@@ -221,7 +221,7 @@ public:
 
 public:
 	idx_t MaxThreads() override {
-		auto &sink = (BlockwiseNLJoinGlobalState &)*op.sink_state;
+		auto &sink = op.sink_state->Cast<BlockwiseNLJoinGlobalState>();
 		return sink.right_outer.MaxThreads();
 	}
 };
@@ -230,7 +230,7 @@ class BlockwiseNLJoinLocalScanState : public LocalSourceState {
 public:
 	explicit BlockwiseNLJoinLocalScanState(const PhysicalBlockwiseNLJoin &op, BlockwiseNLJoinGlobalScanState &gstate) {
 		D_ASSERT(op.sink_state);
-		auto &sink = (BlockwiseNLJoinGlobalState &)*op.sink_state;
+		auto &sink = op.sink_state->Cast<BlockwiseNLJoinGlobalState>();
 		sink.right_outer.InitializeScan(gstate.scan_state, scan_state);
 	}
 
@@ -250,7 +250,7 @@ void PhysicalBlockwiseNLJoin::GetData(ExecutionContext &context, DataChunk &chun
                                       LocalSourceState &lstate_p) const {
 	D_ASSERT(IsRightOuterJoin(join_type));
 	// check if we need to scan any unmatched tuples from the RHS for the full/right outer join
-	auto &sink = (BlockwiseNLJoinGlobalState &)*sink_state;
+	auto &sink = sink_state->Cast<BlockwiseNLJoinGlobalState>();
 	auto &gstate = (BlockwiseNLJoinGlobalScanState &)gstate_p;
 	auto &lstate = (BlockwiseNLJoinLocalScanState &)lstate_p;
 

package/src/duckdb/src/execution/operator/join/physical_cross_product.cpp

@@ -34,7 +34,7 @@ unique_ptr<GlobalSinkState> PhysicalCrossProduct::GetGlobalSinkState(ClientConte
 
 SinkResultType PhysicalCrossProduct::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate_p,
                                           DataChunk &input) const {
-	auto &sink = (CrossProductGlobalState &)state;
+	auto &sink = state.Cast<CrossProductGlobalState>();
 	lock_guard<mutex> client_guard(sink.rhs_lock);
 	sink.rhs_materialized.Append(sink.append_state, input);
 	return SinkResultType::NEED_MORE_INPUT;
@@ -123,13 +123,13 @@ public:
 };
 
 unique_ptr<OperatorState> PhysicalCrossProduct::GetOperatorState(ExecutionContext &context) const {
-	auto &sink = (CrossProductGlobalState &)*sink_state;
+	auto &sink = sink_state->Cast<CrossProductGlobalState>();
 	return make_uniq<CrossProductOperatorState>(sink.rhs_materialized);
 }
 
 OperatorResultType PhysicalCrossProduct::ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
                                                          GlobalOperatorState &gstate, OperatorState &state_p) const {
-	auto &state = (CrossProductOperatorState &)state_p;
+	auto &state = state_p.Cast<CrossProductOperatorState>();
 	return state.executor.Execute(input, chunk);
 }
 

package/src/duckdb/src/execution/operator/join/physical_delim_join.cpp

@@ -92,15 +92,15 @@ unique_ptr<LocalSinkState> PhysicalDelimJoin::GetLocalSinkState(ExecutionContext
 
 SinkResultType PhysicalDelimJoin::Sink(ExecutionContext &context, GlobalSinkState &state_p, LocalSinkState &lstate_p,
                                        DataChunk &input) const {
-	auto &lstate = (DelimJoinLocalState &)lstate_p;
+	auto &lstate = lstate_p.Cast<DelimJoinLocalState>();
 	lstate.lhs_data.Append(lstate.append_state, input);
 	distinct->Sink(context, *distinct->sink_state, *lstate.distinct_state, input);
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
 void PhysicalDelimJoin::Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate_p) const {
-	auto &lstate = (DelimJoinLocalState &)lstate_p;
-	auto &gstate = (DelimJoinGlobalState &)state;
+	auto &lstate = lstate_p.Cast<DelimJoinLocalState>();
+	auto &gstate = state.Cast<DelimJoinGlobalState>();
 	gstate.Merge(lstate.lhs_data);
 	distinct->Combine(context, *distinct->sink_state, *lstate.distinct_state);
 }