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

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

@@ -187,8 +187,8 @@ unique_ptr<LocalSinkState> PhysicalHashJoin::GetLocalSinkState(ExecutionContext
 
 SinkResultType PhysicalHashJoin::Sink(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p,
                                       DataChunk &input) const {
-	auto &gstate = (HashJoinGlobalSinkState &)gstate_p;
-	auto &lstate = (HashJoinLocalSinkState &)lstate_p;
+	auto &gstate = gstate_p.Cast<HashJoinGlobalSinkState>();
+	auto &lstate = lstate_p.Cast<HashJoinLocalSinkState>();
 
 	// resolve the join keys for the right chunk
 	lstate.join_keys.Reset();
@@ -223,8 +223,8 @@ SinkResultType PhysicalHashJoin::Sink(ExecutionContext &context, GlobalSinkState
 }
 
 void PhysicalHashJoin::Combine(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const {
-	auto &gstate = (HashJoinGlobalSinkState &)gstate_p;
-	auto &lstate = (HashJoinLocalSinkState &)lstate_p;
+	auto &gstate = gstate_p.Cast<HashJoinGlobalSinkState>();
+	auto &lstate = lstate_p.Cast<HashJoinLocalSinkState>();
 	if (lstate.hash_table) {
 		lock_guard<mutex> local_ht_lock(gstate.lock);
 		gstate.local_hash_tables.push_back(std::move(lstate.hash_table));
@@ -375,7 +375,7 @@ public:
 
 SinkFinalizeType PhysicalHashJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
                                             GlobalSinkState &gstate) const {
-	auto &sink = (HashJoinGlobalSinkState &)gstate;
+	auto &sink = gstate.Cast<HashJoinGlobalSinkState>();
 
 	if (sink.external) {
 		D_ASSERT(can_go_external);
@@ -438,7 +438,7 @@ public:
 
 unique_ptr<OperatorState> PhysicalHashJoin::GetOperatorState(ExecutionContext &context) const {
 	auto &allocator = Allocator::Get(context.client);
-	auto &sink = (HashJoinGlobalSinkState &)*sink_state;
+	auto &sink = sink_state->Cast<HashJoinGlobalSinkState>();
 	auto state = make_uniq<HashJoinOperatorState>(context.client);
 	if (sink.perfect_join_executor) {
 		state->perfect_hash_join_state = sink.perfect_join_executor->GetOperatorState(context);
@@ -458,8 +458,8 @@ unique_ptr<OperatorState> PhysicalHashJoin::GetOperatorState(ExecutionContext &c
 
 OperatorResultType PhysicalHashJoin::ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
                                                      GlobalOperatorState &gstate, OperatorState &state_p) const {
-	auto &state = (HashJoinOperatorState &)state_p;
-	auto &sink = (HashJoinGlobalSinkState &)*sink_state;
+	auto &state = state_p.Cast<HashJoinOperatorState>();
+	auto &sink = sink_state->Cast<HashJoinGlobalSinkState>();
 	D_ASSERT(sink.finalized);
 	D_ASSERT(!sink.scanned_data);
 
@@ -741,7 +741,7 @@ HashJoinLocalSourceState::HashJoinLocalSourceState(const PhysicalHashJoin &op, A
 	auto &chunk_state = probe_local_scan.current_chunk_state;
 	chunk_state.properties = ColumnDataScanProperties::ALLOW_ZERO_COPY;
 
-	auto &sink = (HashJoinGlobalSinkState &)*op.sink_state;
+	auto &sink = op.sink_state->Cast<HashJoinGlobalSinkState>();
 	probe_chunk.Initialize(allocator, sink.probe_types);
 	join_keys.Initialize(allocator, op.condition_types);
 	payload.Initialize(allocator, op.children[0]->types);
@@ -853,9 +853,9 @@ void HashJoinLocalSourceState::ScanFullOuter(HashJoinGlobalSinkState &sink, Hash
 
 void PhysicalHashJoin::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
                                LocalSourceState &lstate_p) const {
-	auto &sink = (HashJoinGlobalSinkState &)*sink_state;
-	auto &gstate = (HashJoinGlobalSourceState &)gstate_p;
-	auto &lstate = (HashJoinLocalSourceState &)lstate_p;
+	auto &sink = sink_state->Cast<HashJoinGlobalSinkState>();
+	auto &gstate = gstate_p.Cast<HashJoinGlobalSourceState>();
+	auto &lstate = lstate_p.Cast<HashJoinLocalSourceState>();
 	sink.scanned_data = true;
 
 	if (!sink.external) {

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

@@ -128,7 +128,7 @@ unique_ptr<GlobalSinkState> PhysicalIEJoin::GetGlobalSinkState(ClientContext &co
 unique_ptr<LocalSinkState> PhysicalIEJoin::GetLocalSinkState(ExecutionContext &context) const {
 	idx_t sink_child = 0;
 	if (sink_state) {
-		const auto &ie_sink = (IEJoinGlobalState &)*sink_state;
+		const auto &ie_sink = sink_state->Cast<IEJoinGlobalState>();
 		sink_child = ie_sink.child;
 	}
 	return make_uniq<IEJoinLocalState>(context.client, *this, sink_child);
@@ -136,8 +136,8 @@ unique_ptr<LocalSinkState> PhysicalIEJoin::GetLocalSinkState(ExecutionContext &c
 
 SinkResultType PhysicalIEJoin::Sink(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p,
                                     DataChunk &input) const {
-	auto &gstate = (IEJoinGlobalState &)gstate_p;
-	auto &lstate = (IEJoinLocalState &)lstate_p;
+	auto &gstate = gstate_p.Cast<IEJoinGlobalState>();
+	auto &lstate = lstate_p.Cast<IEJoinLocalState>();
 
 	gstate.Sink(input, lstate);
 
@@ -145,8 +145,8 @@ SinkResultType PhysicalIEJoin::Sink(ExecutionContext &context, GlobalSinkState &
 }
 
 void PhysicalIEJoin::Combine(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const {
-	auto &gstate = (IEJoinGlobalState &)gstate_p;
-	auto &lstate = (IEJoinLocalState &)lstate_p;
+	auto &gstate = gstate_p.Cast<IEJoinGlobalState>();
+	auto &lstate = lstate_p.Cast<IEJoinLocalState>();
 	gstate.tables[gstate.child]->Combine(lstate.table);
 	auto &client_profiler = QueryProfiler::Get(context.client);
 
@@ -159,7 +159,7 @@ void PhysicalIEJoin::Combine(ExecutionContext &context, GlobalSinkState &gstate_
 //===--------------------------------------------------------------------===//
 SinkFinalizeType PhysicalIEJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
                                           GlobalSinkState &gstate_p) const {
-	auto &gstate = (IEJoinGlobalState &)gstate_p;
+	auto &gstate = gstate_p.Cast<IEJoinGlobalState>();
 	auto &table = *gstate.tables[gstate.child];
 	auto &global_sort_state = table.global_sort_state;
 
@@ -701,8 +701,8 @@ public:
 };
 
 void PhysicalIEJoin::ResolveComplexJoin(ExecutionContext &context, DataChunk &chunk, LocalSourceState &state_p) const {
-	auto &state = (IEJoinLocalSourceState &)state_p;
-	auto &ie_sink = (IEJoinGlobalState &)*sink_state;
+	auto &state = state_p.Cast<IEJoinLocalSourceState>();
+	auto &ie_sink = sink_state->Cast<IEJoinGlobalState>();
 	auto &left_table = *ie_sink.tables[0];
 	auto &right_table = *ie_sink.tables[1];
 
@@ -822,7 +822,7 @@ public:
 public:
 	idx_t MaxThreads() override {
 		// We can't leverage any more threads than block pairs.
-		const auto &sink_state = ((IEJoinGlobalState &)*op.sink_state);
+		const auto &sink_state = (op.sink_state->Cast<IEJoinGlobalState>());
 		return sink_state.tables[0]->BlockCount() * sink_state.tables[1]->BlockCount();
 	}
 
@@ -929,9 +929,9 @@ unique_ptr<LocalSourceState> PhysicalIEJoin::GetLocalSourceState(ExecutionContex
 
 void PhysicalIEJoin::GetData(ExecutionContext &context, DataChunk &result, GlobalSourceState &gstate,
                              LocalSourceState &lstate) const {
-	auto &ie_sink = (IEJoinGlobalState &)*sink_state;
-	auto &ie_gstate = (IEJoinGlobalSourceState &)gstate;
-	auto &ie_lstate = (IEJoinLocalSourceState &)lstate;
+	auto &ie_sink = sink_state->Cast<IEJoinGlobalState>();
+	auto &ie_gstate = gstate.Cast<IEJoinGlobalSourceState>();
+	auto &ie_lstate = lstate.Cast<IEJoinLocalSourceState>();
 
 	ie_gstate.Initialize(ie_sink);
 

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

@@ -109,9 +109,9 @@ unique_ptr<OperatorState> PhysicalIndexJoin::GetOperatorState(ExecutionContext &
 void PhysicalIndexJoin::Output(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
                                OperatorState &state_p) const {
 	auto &phy_tbl_scan = (PhysicalTableScan &)*children[1];
-	auto &bind_tbl = (TableScanBindData &)*phy_tbl_scan.bind_data;
+	auto &bind_tbl = phy_tbl_scan.bind_data->Cast<TableScanBindData>();
 	auto &transaction = DuckTransaction::Get(context.client, *bind_tbl.table->catalog);
-	auto &state = (IndexJoinOperatorState &)state_p;
+	auto &state = state_p.Cast<IndexJoinOperatorState>();
 
 	auto &tbl = bind_tbl.table->GetStorage();
 	idx_t output_sel_idx = 0;
@@ -164,8 +164,9 @@ void PhysicalIndexJoin::Output(ExecutionContext &context, DataChunk &input, Data
 
 void PhysicalIndexJoin::GetRHSMatches(ExecutionContext &context, DataChunk &input, OperatorState &state_p) const {
 
-	auto &state = (IndexJoinOperatorState &)state_p;
-	auto &art = (ART &)*index;
+	auto &state = state_p.Cast<IndexJoinOperatorState>();
+	auto &art = index->Cast<ART>();
+	;
 
 	// generate the keys for this chunk
 	state.arena_allocator.Reset();
@@ -197,7 +198,7 @@ void PhysicalIndexJoin::GetRHSMatches(ExecutionContext &context, DataChunk &inpu
 
 OperatorResultType PhysicalIndexJoin::ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
                                                       GlobalOperatorState &gstate, OperatorState &state_p) const {
-	auto &state = (IndexJoinOperatorState &)state_p;
+	auto &state = state_p.Cast<IndexJoinOperatorState>();
 
 	state.result_size = 0;
 	if (state.first_fetch) {

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

@@ -59,13 +59,13 @@ void PhysicalJoin::BuildJoinPipelines(Pipeline &current, MetaPipeline &meta_pipe
 
 	// Join can become a source operator if it's RIGHT/OUTER, or if the hash join goes out-of-core
 	bool add_child_pipeline = false;
-	auto &join_op = (PhysicalJoin &)op;
+	auto &join_op = op.Cast<PhysicalJoin>();
 	if (IsRightOuterJoin(join_op.join_type)) {
 		add_child_pipeline = true;
 	}
 
 	if (join_op.type == PhysicalOperatorType::HASH_JOIN) {
-		auto &hash_join_op = (PhysicalHashJoin &)join_op;
+		auto &hash_join_op = join_op.Cast<PhysicalHashJoin>();
 		hash_join_op.can_go_external = !meta_pipeline.HasRecursiveCTE();
 		if (hash_join_op.can_go_external) {
 			add_child_pipeline = true;

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

@@ -169,8 +169,8 @@ vector<LogicalType> PhysicalNestedLoopJoin::GetJoinTypes() const {
 
 SinkResultType PhysicalNestedLoopJoin::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
                                             DataChunk &input) const {
-	auto &gstate = (NestedLoopJoinGlobalState &)state;
-	auto &nlj_state = (NestedLoopJoinLocalState &)lstate;
+	auto &gstate = state.Cast<NestedLoopJoinGlobalState>();
+	auto &nlj_state = lstate.Cast<NestedLoopJoinLocalState>();
 
 	// resolve the join expression of the right side
 	nlj_state.right_condition.Reset();
@@ -192,7 +192,7 @@ SinkResultType PhysicalNestedLoopJoin::Sink(ExecutionContext &context, GlobalSin
 }
 
 void PhysicalNestedLoopJoin::Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const {
-	auto &state = (NestedLoopJoinLocalState &)lstate;
+	auto &state = lstate.Cast<NestedLoopJoinLocalState>();
 	auto &client_profiler = QueryProfiler::Get(context.client);
 
 	context.thread.profiler.Flush(this, &state.rhs_executor, "rhs_executor", 1);
@@ -201,7 +201,7 @@ void PhysicalNestedLoopJoin::Combine(ExecutionContext &context, GlobalSinkState
 
 SinkFinalizeType PhysicalNestedLoopJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
                                                   GlobalSinkState &gstate_p) const {
-	auto &gstate = (NestedLoopJoinGlobalState &)gstate_p;
+	auto &gstate = gstate_p.Cast<NestedLoopJoinGlobalState>();
 	gstate.right_outer.Initialize(gstate.right_payload_data.Count());
 	if (gstate.right_payload_data.Count() == 0 && EmptyResultIfRHSIsEmpty()) {
 		return SinkFinalizeType::NO_OUTPUT_POSSIBLE;
@@ -267,7 +267,7 @@ unique_ptr<OperatorState> PhysicalNestedLoopJoin::GetOperatorState(ExecutionCont
 OperatorResultType PhysicalNestedLoopJoin::ExecuteInternal(ExecutionContext &context, DataChunk &input,
                                                            DataChunk &chunk, GlobalOperatorState &gstate_p,
                                                            OperatorState &state_p) const {
-	auto &gstate = (NestedLoopJoinGlobalState &)*sink_state;
+	auto &gstate = sink_state->Cast<NestedLoopJoinGlobalState>();
 
 	if (gstate.right_payload_data.Count() == 0) {
 		// empty RHS
@@ -298,8 +298,8 @@ OperatorResultType PhysicalNestedLoopJoin::ExecuteInternal(ExecutionContext &con
 
 void PhysicalNestedLoopJoin::ResolveSimpleJoin(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
                                                OperatorState &state_p) const {
-	auto &state = (PhysicalNestedLoopJoinState &)state_p;
-	auto &gstate = (NestedLoopJoinGlobalState &)*sink_state;
+	auto &state = state_p.Cast<PhysicalNestedLoopJoinState>();
+	auto &gstate = sink_state->Cast<NestedLoopJoinGlobalState>();
 
 	// resolve the left join condition for the current chunk
 	state.left_condition.Reset();
@@ -327,8 +327,8 @@ void PhysicalNestedLoopJoin::ResolveSimpleJoin(ExecutionContext &context, DataCh
 
 OperatorResultType PhysicalNestedLoopJoin::ResolveComplexJoin(ExecutionContext &context, DataChunk &input,
                                                               DataChunk &chunk, OperatorState &state_p) const {
-	auto &state = (PhysicalNestedLoopJoinState &)state_p;
-	auto &gstate = (NestedLoopJoinGlobalState &)*sink_state;
+	auto &state = state_p.Cast<PhysicalNestedLoopJoinState>();
+	auto &gstate = sink_state->Cast<NestedLoopJoinGlobalState>();
 
 	idx_t match_count;
 	do {
@@ -412,7 +412,7 @@ class NestedLoopJoinGlobalScanState : public GlobalSourceState {
 public:
 	explicit NestedLoopJoinGlobalScanState(const PhysicalNestedLoopJoin &op) : op(op) {
 		D_ASSERT(op.sink_state);
-		auto &sink = (NestedLoopJoinGlobalState &)*op.sink_state;
+		auto &sink = op.sink_state->Cast<NestedLoopJoinGlobalState>();
 		sink.right_outer.InitializeScan(sink.right_payload_data, scan_state);
 	}
 
@@ -421,7 +421,7 @@ public:
 
 public:
 	idx_t MaxThreads() override {
-		auto &sink = (NestedLoopJoinGlobalState &)*op.sink_state;
+		auto &sink = op.sink_state->Cast<NestedLoopJoinGlobalState>();
 		return sink.right_outer.MaxThreads();
 	}
 };
@@ -430,7 +430,7 @@ class NestedLoopJoinLocalScanState : public LocalSourceState {
 public:
 	explicit NestedLoopJoinLocalScanState(const PhysicalNestedLoopJoin &op, NestedLoopJoinGlobalScanState &gstate) {
 		D_ASSERT(op.sink_state);
-		auto &sink = (NestedLoopJoinGlobalState &)*op.sink_state;
+		auto &sink = op.sink_state->Cast<NestedLoopJoinGlobalState>();
 		sink.right_outer.InitializeScan(gstate.scan_state, scan_state);
 	}
 
@@ -450,7 +450,7 @@ void PhysicalNestedLoopJoin::GetData(ExecutionContext &context, DataChunk &chunk
                                      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 = (NestedLoopJoinGlobalState &)*sink_state;
+	auto &sink = sink_state->Cast<NestedLoopJoinGlobalState>();
 	auto &gstate = (NestedLoopJoinGlobalScanState &)gstate_p;
 	auto &lstate = (NestedLoopJoinLocalScanState &)lstate_p;
 

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

@@ -110,8 +110,8 @@ unique_ptr<LocalSinkState> PhysicalPiecewiseMergeJoin::GetLocalSinkState(Executi
 
 SinkResultType PhysicalPiecewiseMergeJoin::Sink(ExecutionContext &context, GlobalSinkState &gstate_p,
                                                 LocalSinkState &lstate_p, DataChunk &input) const {
-	auto &gstate = (MergeJoinGlobalState &)gstate_p;
-	auto &lstate = (MergeJoinLocalState &)lstate_p;
+	auto &gstate = gstate_p.Cast<MergeJoinGlobalState>();
+	auto &lstate = lstate_p.Cast<MergeJoinLocalState>();
 
 	gstate.Sink(input, lstate);
 
@@ -120,8 +120,8 @@ SinkResultType PhysicalPiecewiseMergeJoin::Sink(ExecutionContext &context, Globa
 
 void PhysicalPiecewiseMergeJoin::Combine(ExecutionContext &context, GlobalSinkState &gstate_p,
                                          LocalSinkState &lstate_p) const {
-	auto &gstate = (MergeJoinGlobalState &)gstate_p;
-	auto &lstate = (MergeJoinLocalState &)lstate_p;
+	auto &gstate = gstate_p.Cast<MergeJoinGlobalState>();
+	auto &lstate = lstate_p.Cast<MergeJoinLocalState>();
 	gstate.table->Combine(lstate.table);
 	auto &client_profiler = QueryProfiler::Get(context.client);
 
@@ -134,7 +134,7 @@ void PhysicalPiecewiseMergeJoin::Combine(ExecutionContext &context, GlobalSinkSt
 //===--------------------------------------------------------------------===//
 SinkFinalizeType PhysicalPiecewiseMergeJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
                                                       GlobalSinkState &gstate_p) const {
-	auto &gstate = (MergeJoinGlobalState &)gstate_p;
+	auto &gstate = gstate_p.Cast<MergeJoinGlobalState>();
 	auto &global_sort_state = gstate.table->global_sort_state;
 
 	if (IsRightOuterJoin(join_type)) {
@@ -386,7 +386,7 @@ static idx_t MergeJoinSimpleBlocks(PiecewiseMergeJoinState &lstate, MergeJoinGlo
 void PhysicalPiecewiseMergeJoin::ResolveSimpleJoin(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
                                                    OperatorState &state_p) const {
 	auto &state = (PiecewiseMergeJoinState &)state_p;
-	auto &gstate = (MergeJoinGlobalState &)*sink_state;
+	auto &gstate = sink_state->Cast<MergeJoinGlobalState>();
 
 	state.ResolveJoinKeys(input);
 	auto &lhs_table = *state.lhs_local_table;
@@ -508,7 +508,7 @@ static idx_t MergeJoinComplexBlocks(BlockMergeInfo &l, BlockMergeInfo &r, const
 OperatorResultType PhysicalPiecewiseMergeJoin::ResolveComplexJoin(ExecutionContext &context, DataChunk &input,
                                                                   DataChunk &chunk, OperatorState &state_p) const {
 	auto &state = (PiecewiseMergeJoinState &)state_p;
-	auto &gstate = (MergeJoinGlobalState &)*sink_state;
+	auto &gstate = sink_state->Cast<MergeJoinGlobalState>();
 	auto &rsorted = *gstate.table->global_sort_state.sorted_blocks[0];
 	const auto left_cols = input.ColumnCount();
 	const auto tail_cols = conditions.size() - 1;
@@ -623,7 +623,7 @@ OperatorResultType PhysicalPiecewiseMergeJoin::ResolveComplexJoin(ExecutionConte
 OperatorResultType PhysicalPiecewiseMergeJoin::ExecuteInternal(ExecutionContext &context, DataChunk &input,
                                                                DataChunk &chunk, GlobalOperatorState &gstate_p,
                                                                OperatorState &state) const {
-	auto &gstate = (MergeJoinGlobalState &)*sink_state;
+	auto &gstate = sink_state->Cast<MergeJoinGlobalState>();
 
 	if (gstate.Count() == 0) {
 		// empty RHS
@@ -668,7 +668,7 @@ public:
 
 public:
 	idx_t MaxThreads() override {
-		auto &sink = (MergeJoinGlobalState &)*op.sink_state;
+		auto &sink = op.sink_state->Cast<MergeJoinGlobalState>();
 		return sink.Count() / (STANDARD_VECTOR_SIZE * idx_t(10));
 	}
 };
@@ -681,7 +681,7 @@ void PhysicalPiecewiseMergeJoin::GetData(ExecutionContext &context, DataChunk &r
                                          LocalSourceState &lstate) 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 = (MergeJoinGlobalState &)*sink_state;
+	auto &sink = sink_state->Cast<MergeJoinGlobalState>();
 	auto &state = (PiecewiseJoinScanState &)gstate;
 
 	lock_guard<mutex> l(state.lock);

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

@@ -46,7 +46,7 @@ unique_ptr<GlobalSinkState> PhysicalPositionalJoin::GetGlobalSinkState(ClientCon
 
 SinkResultType PhysicalPositionalJoin::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate_p,
                                             DataChunk &input) const {
-	auto &sink = (PositionalJoinGlobalState &)state;
+	auto &sink = state.Cast<PositionalJoinGlobalState>();
 	lock_guard<mutex> client_guard(sink.rhs_lock);
 	sink.rhs.Append(sink.append_state, input);
 	return SinkResultType::NEED_MORE_INPUT;
@@ -136,7 +136,7 @@ void PositionalJoinGlobalState::Execute(DataChunk &input, DataChunk &output) {
 
 OperatorResultType PhysicalPositionalJoin::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
                                                    GlobalOperatorState &gstate, OperatorState &state_p) const {
-	auto &sink = (PositionalJoinGlobalState &)*sink_state;
+	auto &sink = sink_state->Cast<PositionalJoinGlobalState>();
 	sink.Execute(input, chunk);
 	return OperatorResultType::NEED_MORE_INPUT;
 }
@@ -173,7 +173,7 @@ void PositionalJoinGlobalState::GetData(DataChunk &output) {
 
 void PhysicalPositionalJoin::GetData(ExecutionContext &context, DataChunk &result, GlobalSourceState &gstate,
                                      LocalSourceState &lstate) const {
-	auto &sink = (PositionalJoinGlobalState &)*sink_state;
+	auto &sink = sink_state->Cast<PositionalJoinGlobalState>();
 	sink.GetData(result);
 }
 

package/src/duckdb/src/execution/operator/order/physical_order.cpp

@@ -71,8 +71,8 @@ unique_ptr<LocalSinkState> PhysicalOrder::GetLocalSinkState(ExecutionContext &co
 
 SinkResultType PhysicalOrder::Sink(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p,
                                    DataChunk &input) const {
-	auto &gstate = (OrderGlobalSinkState &)gstate_p;
-	auto &lstate = (OrderLocalSinkState &)lstate_p;
+	auto &gstate = gstate_p.Cast<OrderGlobalSinkState>();
+	auto &lstate = lstate_p.Cast<OrderLocalSinkState>();
 
 	auto &global_sort_state = gstate.global_sort_state;
 	auto &local_sort_state = lstate.local_sort_state;
@@ -103,8 +103,8 @@ SinkResultType PhysicalOrder::Sink(ExecutionContext &context, GlobalSinkState &g
 }
 
 void PhysicalOrder::Combine(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const {
-	auto &gstate = (OrderGlobalSinkState &)gstate_p;
-	auto &lstate = (OrderLocalSinkState &)lstate_p;
+	auto &gstate = gstate_p.Cast<OrderGlobalSinkState>();
+	auto &lstate = lstate_p.Cast<OrderLocalSinkState>();
 	gstate.global_sort_state.AddLocalState(lstate.local_sort_state);
 }
 
@@ -165,7 +165,7 @@ public:
 
 SinkFinalizeType PhysicalOrder::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
                                          GlobalSinkState &gstate_p) const {
-	auto &state = (OrderGlobalSinkState &)gstate_p;
+	auto &state = gstate_p.Cast<OrderGlobalSinkState>();
 	auto &global_sort_state = state.global_sort_state;
 
 	if (global_sort_state.sorted_blocks.empty()) {
@@ -215,7 +215,7 @@ public:
 };
 
 unique_ptr<GlobalSourceState> PhysicalOrder::GetGlobalSourceState(ClientContext &context) const {
-	auto &sink = (OrderGlobalSinkState &)*this->sink_state;
+	auto &sink = this->sink_state->Cast<OrderGlobalSinkState>();
 	return make_uniq<PhysicalOrderGlobalSourceState>(sink);
 }
 
@@ -232,14 +232,14 @@ public:
 
 unique_ptr<LocalSourceState> PhysicalOrder::GetLocalSourceState(ExecutionContext &context,
                                                                 GlobalSourceState &gstate_p) const {
-	auto &gstate = (PhysicalOrderGlobalSourceState &)gstate_p;
+	auto &gstate = gstate_p.Cast<PhysicalOrderGlobalSourceState>();
 	return make_uniq<PhysicalOrderLocalSourceState>(gstate);
 }
 
 void PhysicalOrder::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
                             LocalSourceState &lstate_p) const {
-	auto &gstate = (PhysicalOrderGlobalSourceState &)gstate_p;
-	auto &lstate = (PhysicalOrderLocalSourceState &)lstate_p;
+	auto &gstate = gstate_p.Cast<PhysicalOrderGlobalSourceState>();
+	auto &lstate = lstate_p.Cast<PhysicalOrderLocalSourceState>();
 
 	if (lstate.scanner && lstate.scanner->Remaining() == 0) {
 		lstate.batch_index = gstate.next_batch_index++;
@@ -251,7 +251,7 @@ void PhysicalOrder::GetData(ExecutionContext &context, DataChunk &chunk, GlobalS
 	}
 
 	if (!lstate.scanner) {
-		auto &sink = (OrderGlobalSinkState &)*this->sink_state;
+		auto &sink = this->sink_state->Cast<OrderGlobalSinkState>();
 		auto &global_sort_state = sink.global_sort_state;
 		lstate.scanner = make_uniq<PayloadScanner>(global_sort_state, lstate.batch_index, true);
 	}
@@ -261,7 +261,7 @@ void PhysicalOrder::GetData(ExecutionContext &context, DataChunk &chunk, GlobalS
 
 idx_t PhysicalOrder::GetBatchIndex(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
                                    LocalSourceState &lstate_p) const {
-	auto &lstate = (PhysicalOrderLocalSourceState &)lstate_p;
+	auto &lstate = lstate_p.Cast<PhysicalOrderLocalSourceState>();
 	return lstate.batch_index;
 }
 

package/src/duckdb/src/execution/operator/order/physical_top_n.cpp

@@ -438,7 +438,7 @@ unique_ptr<GlobalSinkState> PhysicalTopN::GetGlobalSinkState(ClientContext &cont
 SinkResultType PhysicalTopN::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
                                   DataChunk &input) const {
 	// append to the local sink state
-	auto &sink = (TopNLocalState &)lstate;
+	auto &sink = lstate.Cast<TopNLocalState>();
 	sink.heap.Sink(input);
 	sink.heap.Reduce();
 	return SinkResultType::NEED_MORE_INPUT;
@@ -448,8 +448,8 @@ SinkResultType PhysicalTopN::Sink(ExecutionContext &context, GlobalSinkState &st
 // Combine
 //===--------------------------------------------------------------------===//
 void PhysicalTopN::Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate_p) const {
-	auto &gstate = (TopNGlobalState &)state;
-	auto &lstate = (TopNLocalState &)lstate_p;
+	auto &gstate = state.Cast<TopNGlobalState>();
+	auto &lstate = lstate_p.Cast<TopNLocalState>();
 
 	// scan the local top N and append it to the global heap
 	lock_guard<mutex> glock(gstate.lock);
@@ -461,7 +461,7 @@ void PhysicalTopN::Combine(ExecutionContext &context, GlobalSinkState &state, Lo
 //===--------------------------------------------------------------------===//
 SinkFinalizeType PhysicalTopN::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
                                         GlobalSinkState &gstate_p) const {
-	auto &gstate = (TopNGlobalState &)gstate_p;
+	auto &gstate = gstate_p.Cast<TopNGlobalState>();
 	// global finalize: compute the final top N
 	gstate.heap.Finalize();
 	return SinkFinalizeType::READY;
@@ -485,8 +485,8 @@ void PhysicalTopN::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSo
 	if (limit == 0) {
 		return;
 	}
-	auto &state = (TopNOperatorState &)gstate_p;
-	auto &gstate = (TopNGlobalState &)*sink_state;
+	auto &state = gstate_p.Cast<TopNOperatorState>();
+	auto &gstate = sink_state->Cast<TopNGlobalState>();
 
 	if (!state.initialized) {
 		gstate.heap.InitializeScan(state.state, true);

package/src/duckdb/src/execution/operator/persistent/physical_batch_insert.cpp

@@ -285,8 +285,8 @@ unique_ptr<LocalSinkState> PhysicalBatchInsert::GetLocalSinkState(ExecutionConte
 
 SinkResultType PhysicalBatchInsert::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate_p,
                                          DataChunk &chunk) const {
-	auto &gstate = (BatchInsertGlobalState &)state;
-	auto &lstate = (BatchInsertLocalState &)lstate_p;
+	auto &gstate = state.Cast<BatchInsertGlobalState>();
+	auto &lstate = lstate_p.Cast<BatchInsertLocalState>();
 
 	auto table = gstate.table;
 	PhysicalInsert::ResolveDefaults(table, chunk, column_index_map, lstate.default_executor, lstate.insert_chunk);
@@ -319,8 +319,8 @@ SinkResultType PhysicalBatchInsert::Sink(ExecutionContext &context, GlobalSinkSt
 
 void PhysicalBatchInsert::Combine(ExecutionContext &context, GlobalSinkState &gstate_p,
                                   LocalSinkState &lstate_p) const {
-	auto &gstate = (BatchInsertGlobalState &)gstate_p;
-	auto &lstate = (BatchInsertLocalState &)lstate_p;
+	auto &gstate = gstate_p.Cast<BatchInsertGlobalState>();
+	auto &lstate = lstate_p.Cast<BatchInsertLocalState>();
 	auto &client_profiler = QueryProfiler::Get(context.client);
 	context.thread.profiler.Flush(this, &lstate.default_executor, "default_executor", 1);
 	client_profiler.Flush(context.thread.profiler);
@@ -338,7 +338,7 @@ void PhysicalBatchInsert::Combine(ExecutionContext &context, GlobalSinkState &gs
 
 SinkFinalizeType PhysicalBatchInsert::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
                                                GlobalSinkState &gstate_p) const {
-	auto &gstate = (BatchInsertGlobalState &)gstate_p;
+	auto &gstate = gstate_p.Cast<BatchInsertGlobalState>();
 
 	// in the finalize, do a final pass over all of the collections we created and try to merge smaller collections
 	// together
@@ -403,8 +403,8 @@ unique_ptr<GlobalSourceState> PhysicalBatchInsert::GetGlobalSourceState(ClientCo
 
 void PhysicalBatchInsert::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
                                   LocalSourceState &lstate) const {
-	auto &state = (BatchInsertSourceState &)gstate;
-	auto &insert_gstate = (BatchInsertGlobalState &)*sink_state;
+	auto &state = gstate.Cast<BatchInsertSourceState>();
+	auto &insert_gstate = sink_state->Cast<BatchInsertGlobalState>();
 	if (state.finished) {
 		return;
 	}

package/src/duckdb/src/execution/operator/persistent/physical_copy_to_file.cpp

@@ -57,8 +57,8 @@ PhysicalCopyToFile::PhysicalCopyToFile(vector<LogicalType> types, CopyFunction f
 
 SinkResultType PhysicalCopyToFile::Sink(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate,
                                         DataChunk &input) const {
-	auto &g = (CopyToFunctionGlobalState &)gstate;
-	auto &l = (CopyToFunctionLocalState &)lstate;
+	auto &g = gstate.Cast<CopyToFunctionGlobalState>();
+	auto &l = lstate.Cast<CopyToFunctionLocalState>();
 
 	if (partition_output) {
 		l.part_buffer->Append(*l.part_buffer_append_state, input);
@@ -96,8 +96,8 @@ static string CreateDirRecursive(const vector<idx_t> &cols, const vector<string>
 }
 
 void PhysicalCopyToFile::Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const {
-	auto &g = (CopyToFunctionGlobalState &)gstate;
-	auto &l = (CopyToFunctionLocalState &)lstate;
+	auto &g = gstate.Cast<CopyToFunctionGlobalState>();
+	auto &l = lstate.Cast<CopyToFunctionLocalState>();
 
 	if (partition_output) {
 		auto &fs = FileSystem::GetFileSystem(context.client);
@@ -143,7 +143,7 @@ void PhysicalCopyToFile::Combine(ExecutionContext &context, GlobalSinkState &gst
 
 SinkFinalizeType PhysicalCopyToFile::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
                                               GlobalSinkState &gstate_p) const {
-	auto &gstate = (CopyToFunctionGlobalState &)gstate_p;
+	auto &gstate = gstate_p.Cast<CopyToFunctionGlobalState>();
 	if (per_thread_output || partition_output) {
 		// already happened in combine
 		return SinkFinalizeType::READY;
@@ -164,7 +164,7 @@ unique_ptr<LocalSinkState> PhysicalCopyToFile::GetLocalSinkState(ExecutionContex
 	if (partition_output) {
 		auto state = make_uniq<CopyToFunctionLocalState>(nullptr);
 		{
-			auto &g = (CopyToFunctionGlobalState &)*sink_state;
+			auto &g = sink_state->Cast<CopyToFunctionGlobalState>();
 			lock_guard<mutex> glock(g.lock);
 			state->writer_offset = g.last_file_offset++;
 
@@ -179,7 +179,7 @@ unique_ptr<LocalSinkState> PhysicalCopyToFile::GetLocalSinkState(ExecutionContex
 	if (per_thread_output) {
 		idx_t this_file_offset;
 		{
-			auto &g = (CopyToFunctionGlobalState &)*sink_state;
+			auto &g = sink_state->Cast<CopyToFunctionGlobalState>();
 			lock_guard<mutex> glock(g.lock);
 			this_file_offset = g.last_file_offset++;
 		}
@@ -244,7 +244,7 @@ unique_ptr<GlobalSourceState> PhysicalCopyToFile::GetGlobalSourceState(ClientCon
 void PhysicalCopyToFile::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
                                  LocalSourceState &lstate) const {
 	auto &state = (CopyToFileState &)gstate;
-	auto &g = (CopyToFunctionGlobalState &)*sink_state;
+	auto &g = sink_state->Cast<CopyToFunctionGlobalState>();
 	if (state.finished) {
 		return;
 	}

package/src/duckdb/src/execution/operator/persistent/physical_delete.cpp

@@ -32,8 +32,8 @@ public:
 
 SinkResultType PhysicalDelete::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
                                     DataChunk &input) const {
-	auto &gstate = (DeleteGlobalState &)state;
-	auto &ustate = (DeleteLocalState &)lstate;
+	auto &gstate = state.Cast<DeleteGlobalState>();
+	auto &ustate = lstate.Cast<DeleteLocalState>();
 
 	// get rows and
 	auto &transaction = DuckTransaction::Get(context.client, table.db);
@@ -72,7 +72,7 @@ public:
 	explicit DeleteSourceState(const PhysicalDelete &op) : finished(false) {
 		if (op.return_chunk) {
 			D_ASSERT(op.sink_state);
-			auto &g = (DeleteGlobalState &)*op.sink_state;
+			auto &g = op.sink_state->Cast<DeleteGlobalState>();
 			g.return_collection.InitializeScan(scan_state);
 		}
 	}
@@ -87,8 +87,8 @@ unique_ptr<GlobalSourceState> PhysicalDelete::GetGlobalSourceState(ClientContext
 
 void PhysicalDelete::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
                              LocalSourceState &lstate) const {
-	auto &state = (DeleteSourceState &)gstate;
-	auto &g = (DeleteGlobalState &)*sink_state;
+	auto &state = gstate.Cast<DeleteSourceState>();
+	auto &g = sink_state->Cast<DeleteGlobalState>();
 	if (state.finished) {
 		return;
 	}

package/src/duckdb/src/execution/operator/persistent/physical_export.cpp

@@ -97,7 +97,7 @@ unique_ptr<GlobalSourceState> PhysicalExport::GetGlobalSourceState(ClientContext
 
 void PhysicalExport::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
                              LocalSourceState &lstate) const {
-	auto &state = (ExportSourceState &)gstate;
+	auto &state = gstate.Cast<ExportSourceState>();
 	if (state.finished) {
 		return;
 	}